https://springdoc.cn/ Recent content on spring 中文网 Hugo zh-cn Sat, 28 Jun 2025 07:21:36 +0800 https://springdoc.cn/java-25-features/ Sat, 28 Jun 2025 07:21:36 +0800 https://springdoc.cn/java-25-features/ 1、概览 Java 25 即将发布！这个新的短期版本计划于 2025 年 9 月推出，全面增强了 Java 语言、标准库、API 和运行时环境。 本文将带你了解截至 2025 年 6 月 Java 25 引入的所有新特性和变化。通过简单代码示例和详细解析，带你全面了解这些更新。 2、Java 25 新特性详解 Java 25 引入了一系列语言和编译器增强功能，旨在使语言表达更丰富、代码更简洁。这些特性既优化了日常开发体验，也提升了高级模块化场景下的编程效率。 2.1、原始类型模式匹配（JEP 507 - 第三预览版） 现在，模式匹配可支持 switch 和 instanceof 语句中的原始类型。例如： static void test(Object obj) { if (obj instanceof int i) { System.out.println("It's an int: " + i); } } JEP 507 将原始类型纳入 Java 模式匹配框架，使这类表达式更直观并减少样板代码。该提案是语言层面统一类型模式匹配整体规划的重要组成部分。 2.2、模块化导入声明（JEP 511 - 预览版） JEP 511 引入了模块导入声明功能，允许通过 import 语句声明模块依赖关系，从而提升模块化代码的可读性。传统模块依赖仅能在 module-info.java 中使用 requires 指令声明，而该提案支持在 Java 文件顶部通过 import module 语句声明模块依赖（类似传统导包语法），这一改进既增强了代码清晰度，也使开发工具能更精准推断依赖关系。例如： https://springdoc.cn/docker-service-vs-docker-container/ Sun, 22 Jun 2025 16:46:44 +0800 https://springdoc.cn/docker-service-vs-docker-container/ 1、概览 Docker 推动了容器化技术的普及，简化了高度分布式应用的创建、交付和运行流程。我们通常使用 docker container 命令管理独立的 Docker 容器。 Docker 最初聚焦于开发者和开发周期，但现已演进为通过简洁强大的编排器提供编排服务。 本文将带你了解容器化技术及编排器（orchestrator）的必要性，继而分析 Docker 容器与编排服务的区别及其适用场景。 2、容器化与编排技术解析 将应用容器化为自治单元是软件开发周期的关键步骤。然而，随着容器数量增长，部署和管理将面临重大挑战： 少量容器：通过 Docker 手动管理仍可行，故障时可手动重启或更新。 现代架构：应用通常拆分为多个组件，每个组件部署为独立容器。 大规模部署：当数十甚至数百个容器需跨多服务器协同工作时，手动管理将不可行。 此时需引入容器编排引擎。 容器编排工具可自动化容器管理，主要保障以下特性： 资源高效利用。 高可用性。 容错能力。 容器化应用的透明扩展。 在这些工具中，Kubernetes 无疑是应用最广泛且功能最全面的解决方案。 Docker 也提供了内置编排器 Docker Swarm 模式，该模式通过 services（服务）概念实现 Docker 容器的编排。 3、Docker 独立容器 以独立模式运行容器指直接在本地主机启动容器，无需编排器参与。每个容器相互隔离，通过 Docker CLI 或 API 手动管理。 3.1、部署 假设我们需要部署 bael-api（一个小型 REST Web 服务，用于查询最新或即将发布的课程和教程），同时配置存储课程元数据的数据库： $ docker network create bael-network $ docker volume create bael-db-data $ docker container run -d --name db -v bael-db-data:/var/lib/mysql --network bael-network mysql $ docker container run -d --name bael-api -p 8080:8080 --network bael-network bael-api 此处我们创建自定义 Docker 网络确保容器间通信，并配置数据持久化卷。接着使用 docker container run 启动两个容器： https://springdoc.cn/spring-ai-text-to-sql/ Sun, 22 Jun 2025 16:15:51 +0800 https://springdoc.cn/spring-ai-text-to-sql/ 1、概览 现代应用日益采用自然语言界面简化系统交互，这对数据检索尤为实用 —— 非技术用户可直接用自然语言提问。 Text-to-SQL 聊天机器人便是典型实现，它充当人类语言与数据库间的桥梁。通常借助大语言模型（LLM）将自然语言问题转换为可执行 SQL 查询，随后在数据库中执行并返回结果。 本文将带你了解如何使用 Spring AI 构建 Text-to-SQL 聊天机器人。 2、项目设置 在实现聊天机器人前，需引入必要依赖并正确配置应用。 本文基于 Anthropic 的 Claude 模型构建 Text-To-Sql 聊天机器人。注意：本实现不限定特定 AI 模型，也可选用 Hugging Face 或 Ollama 的本地 LLM 作为替代方案。 2.1、依赖 首先在项目的 pom.xml 文件中添加必要依赖： <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-starter-model-anthropic</artifactId> <version>1.0.0</version> </dependency> Anthropic starter 依赖 是对 Anthropic Message API 的封装，我们将通过它与 Claude 模型交互。 接下来在 application.yaml 文件中配置 Anthropic API Key 和聊天模型： spring: ai: anthropic: api-key: ${ANTHROPIC_API_KEY} chat: options: model: claude-opus-4-20250514 我们通过 ${} 属性占位符从环境变量加载 API Key。 https://springdoc.cn/build-fast-production-worthy-ai-apps-with-spring-ai-and-redis/ Fri, 20 Jun 2025 10:16:19 +0800 https://springdoc.cn/build-fast-production-worthy-ai-apps-with-spring-ai-and-redis/ 本文由 Broadcom 的 Spring 开发者倡导者 Josh Long 和 Redis 的应用 AI 工程师 Brian Sam-Bodden 共同撰写，旨在展示如何在 Spring AI 1.0 中使用 Redis。 Spring AI 1.0 是面向 Java 开发的综合性 AI 工程解决方案。受 AI 领域飞速发展的影响，该版本经过了一个重要的开发阶段，现已发布。该版本为 AI 工程师提供了多项核心新功能。Redis 作为 Spring AI 的原生向量数据库，可助力构建高性能 AI 应用。 当前 Java 和 Spring 正处于 AI 应用的黄金时期。大量企业应用基于 Spring Boot 运行，这使其能轻松将 AI 能力集成至现有系统。你可直接将业务逻辑和数据无缝对接 AI 模型，无需复杂改造。 Spring AI 支持多种 AI 模型与技术： Image model（图像模型）：根据文本提示生成图像。 Transcription model（转录模型）：将音频转换为文本。 Embedding model（嵌入模型）：将任意数据转换为向量（专为语义相似性搜索优化的数据类型）。 Chat model（对话模型）：用户最熟悉的类型，可辅助文档修正或诗歌创作（但暂不建议用于讲笑话），虽功能强大但仍存在局限。 在 Spring AI 中，需要解决一些问题：对话模型具有开放性思维，容易偏离主题，需要通过 system prompt（系统提示）来规范其响应结构和形式。 https://springdoc.cn/multimodule-spring-boot-projects-with-maven-gradle-best-practices/ Wed, 18 Jun 2025 10:33:17 +0800 https://springdoc.cn/multimodule-spring-boot-projects-with-maven-gradle-best-practices/ 构建大规模企业级应用通常需要模块化设计、关注点分离和高效的依赖管理。多模块 Spring Boot 项目允许将复杂系统拆分为可管理的独立模块 —— 每个模块职责明确，同时能无缝协作。 本文将带你了解使用 Maven 和 Gradle 组织多模块 Spring Boot 项目的最佳实践。 1、为什么选择多模块架构？ 多模块架构 具有以下优势： 关注点分离：将领域逻辑、Web 接口、持久层和共享工具拆分到独立模块。 提升构建性能：仅需重新构建受影响的模块。 更优的测试与部署：支持模块独立测试和部署。 清晰的依赖管理：确保单向依赖关系。 2、典型模块结构 常见的多模块结构如下所示： root-project/ │ ├── api/ # DTO 和接口 ├── core/ # 业务逻辑与领域（Domain）模型 ├── persistence/ # 数据库访问（例如 JPA、Repository） ├── web/ # REST Controller、Spring Boot main 类 └── shared/ # 公共的工具类、枚举和异常 下图展示了模块间的依赖流向可视化表示： core 模块依赖 api、shared 和 persistence 模块。 web 模块同时依赖 core 和 api 模块。 所有箭头向下指向，表示单向架构。 这种结构提升了复用性和清晰的层级划分： web 依赖 core 和 api。 core 依赖 persistence 和 shared。 api 与 shared 作为依赖根模块。 3、Maven 设置 根目录的 pom. https://springdoc.cn/spring-ai-openai-tts/ Wed, 18 Jun 2025 09:52:40 +0800 https://springdoc.cn/spring-ai-openai-tts/ 1、概览 如今，应用程序极大地受益于神经网络集成，例如知识库、助手或分析引擎。其中一个实际用例是将文本转换为语音。这一过程被称为 文本转语音（Text-to-Speech，TTS），能够以自然逼真、类人的声音自动生成音频内容。 现代 TTS 系统利用深度学习技术处理发音、节奏、语调甚至情感。与早期的基于规则的方法不同，这些模型通过海量数据集训练，可以生成富有表现力的多语言语音，非常适合虚拟助手或包容性教育平台等全球化应用场景。 本文将带你了解如何在 Spring AI 中使用 OpenAI 文本转语音（TTS）。 2、依赖配置 首先，需要添加 spring-ai-starter-model-openai 依赖： <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-starter-model-openai</artifactId> <version>1.1.0</version> </dependency> 接下来，为 OpenAI 模型配置 Spring AI 属性： # Api Key spring.ai.openai.api-key=${OPENAI_API_KEY} # 模型 spring.ai.openai.audio.speech.options.model=tts-1 # 语音风格 spring.ai.openai.audio.speech.options.voice=alloy # 响应的数据格式 spring.ai.openai.audio.speech.options.response-format=mp3 # 语音速度 spring.ai.openai.audio.speech.options.speed=1.0 要使用 OpenAI API，必须设置 OpenAI API Key。同时还需要指定 文本转语音（TTS） 的模型 名称、语音风格、响应格式以及 音频 速度。 3、构建文本转语音应用 现在，构建文本转语音应用。 首先，创建 TextToSpeechService Service 类： @Service public class TextToSpeechService { private OpenAiAudioSpeechModel openAiAudioSpeechModel; // 构造函数注入 @Autowired public TextToSpeechService(OpenAiAudioSpeechModel openAiAudioSpeechModel) { this. https://springdoc.cn/spring-cloud-gateway-vs-netflix-zuul-2-which-api-gateway-should-you-use-in-2025/ Tue, 17 Jun 2025 10:22:28 +0800 https://springdoc.cn/spring-cloud-gateway-vs-netflix-zuul-2-which-api-gateway-should-you-use-in-2025/ API 网关在微服务架构中至关重要，负责路由、负载均衡、安全防护和可观测性。Java 生态中有两大主流方案： Spring Cloud Gateway（SCG）—— Spring 团队提供的现代化响应式方案。 Netflix Zuul 2 —— Zuul 的升级版，专为异步非阻塞 I/O 设计。 但 2025 年哪种更胜一筹？本文将从性能、功能特性和实际适用性进行对比，助你决策。 1、性能对比 基准测试结果（延迟与吞吐量） 指标 Spring Cloud Gateway Netflix Zuul 2 平均延迟（毫秒） 12 25 最大吞吐量（请求数/秒） 15,000 8,000 CPU 使用率 更低（响应式技术栈） 更高（基于 Servlet） 🔹 为何 Spring Cloud Gateway 胜出？ 基于 Project Reactor（非阻塞式）。 无 Servlet 容器开销（与 Zuul 2 不同）。 专为 云原生负载 优化。 🔹 何时 Zuul 2 更合适？ 若已深度集成 Netflix OSS 生态。 需更精细的过滤器（Zuul 2 内置过滤器更丰富）。 2、功能特性对比 功能特性 Spring Cloud Gateway Netflix Zuul 2 协议支持 HTTP/2、WebSockets HTTP/1. https://springdoc.cn/spring-email-guide/ Tue, 17 Jun 2025 09:44:01 +0800 https://springdoc.cn/spring-email-guide/ 1、概览 本文将带你了解如何通过标准 Spring 应用及 Spring Boot 应用发送邮件。前者基于 JavaMail 库实现，后者则使用 spring-boot-starter-mail 依赖。 2、Maven 依赖 首先需在 pom.xml 中添加依赖。 2.1、Spring 以下是标准 Spring 框架所需的依赖配置： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId> <version>6.1.5</version> </dependency> 最新版本可在 此处 获取。 2.2、Spring Boot 而 Spring Boot 则需要添加： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-mail</artifactId> <version>3.1.5</version> </dependency> 最新版本可在 Maven 中央仓库 获取。 3、邮件服务器配置属性 Spring 框架中邮件支持的接口与类按以下结构组织： MailSender 接口：顶层接口，提供发送简单邮件的基础功能。 JavaMailSender 接口：MailSender 的子接口，支持 MIME 消息，通常与。MimeMessageHelper 类配合创建 MimeMessage。建议通过 MimeMessagePreparator 机制使用该接口。 JavaMailSenderImpl 类：实现 JavaMailSender 接口，支持 MimeMessage 和 SimpleMailMessage。 SimpleMailMessage 类：用于创建包含发件人、收件人、抄送、主题和文本内容的简单邮件。 MimeMessagePreparator 接口：为 MIME 消息提供准备机制的回调接口。 MimeMessageHelper 类：创建 MIME 消息的辅助类，支持图片、典型邮件附件及 HTML 格式的文本内容。 以下章节将演示如何使用这些接口与类。 https://springdoc.cn/java-scanner-close/ Sun, 15 Jun 2025 21:19:05 +0800 https://springdoc.cn/java-scanner-close/ 1、简介 当使用 Java 的 Scanner 类读取 System.in（标准输入）输入时，部分 IDE 会提示可能存在资源泄漏。 例如，若未显式关闭 Scanner，可能收到警告：“Resource leak: ‘scanner’ is never closed”。但关闭关联 System.in 的 Scanner 需谨慎处理，以避免意外问题。 本文将带你了解关闭 Scanner 的重要性及在 Java 中的正确操作方式。 2、理解 IDE 提示的异常 在 Java 中，使用文件、网络连接（Socket）和输入流等资源后应关闭资源以释放系统内存。Scanner 类从文件或 System.in 等源读取原始值和字符串输入，由于实现了 Closeable 接口，因此它持有的资源需要在不使用时及时释放。 部分 IDE（如 Eclipse 和 Visual Studio Code）若检测到未正确关闭 Scanner 对象，会显示如下资源泄漏警告： 3、通过 close() 方法关闭 Scanner 在 Java 中，可通过 close() 方法关闭 Scanner 以释放系统资源，这在读取文件或 System.in 时尤为重要。 建议在 finally 代码块中关闭 Scanner，确保即使发生异常也能正确释放资源，避免泄漏： @Test void givenUserName_whenGetGreetingMessage_thenReturnsWelcomeMessage() { String input = "Anees\n"; ByteArrayInputStream inputStream = new ByteArrayInputStream(input. https://springdoc.cn/java-mail-sender-bean-missing/ Sun, 15 Jun 2025 20:44:37 +0800 https://springdoc.cn/java-mail-sender-bean-missing/ 1、简介 本文将带你了解使用 Spring Boot 实现邮件功能时遇到 “Could not autowire org.springframework.mail.javamail.JavaMailSender” 异常的原因以及解决办法。 2、理解异常 首先解释该错误的含义。JavaMailSender 是 Spring 提供的接口，用于抽象邮件发送过程。它继承自 MailSender 接口（提供简单文本邮件的基础功能），特别支持 MIME 消息、附件和 HTML 内容等高级特性。 Spring 的依赖注入机制会自动装配所需 Bean。当遇到 @Autowired 注解或更推荐的构造器注入时，它会从应用上下文（Application Context）中查找匹配的 Bean： @Service public class EmailService { private final JavaMailSender javaMailSender; public EmailService(final JavaMailSender javaMailSender) { this.javaMailSender = javaMailSender; } } 当我们注入 Spring 无法找到的 JavaMailSender Bean 并运行应用时，会抛出以下错误： Field javaMailSender in com.baeldung.email.EmailService required a bean of type 'org.springframework.mail.javamail.JavaMailSender' that could not be found. 或者： Parameter 0 of constructor in com. https://springdoc.cn/gson-expose-vs-serializedname-annotations/ Fri, 13 Jun 2025 10:23:46 +0800 https://springdoc.cn/gson-expose-vs-serializedname-annotations/ 1、简介 Gson 是 Google 开发的开源 Java 库，用于简化对象与 JSON 之间的转换。它提供高效的序列化与反序列化技术，并支持复杂对象处理。 像 Gson 这样的库支持将 JSON 直接映射到 POJO。但某些场景下需要排除特定属性的序列化与反序列化。 本文将带你了解 Gson 库中两个关键注解：@Expose 和 @SerializedName。尽管二者均涉及属性的序列化控制，但适用场景不同。 2、Gson 设置 要使用 Gson，需在 pom.xml 中添加其 Maven 依赖： <dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> <version>2.10.1</version> </dependency> 3、@Expose 注解 Gson 默认会序列化和反序列化 POJO 类的所有字段，除非另有指定。@Expose 注解可覆盖此行为，控制特定字段是否参与序列化或反序列化。 若字段的 serialize 和 deserialize 属性设为 true，Gson 仅会处理带有 @Expose 注解的字段。这两个属性的默认值均为 true。 以下示例展示了一个包含 id、name、age 和 email 的 User 类。由于 email 是敏感信息，我们将其从输出的 JSON 中排除： public class User { @Expose String name; @Expose int age; @Expose(serialize = true, deserialize = false) long id; @Expose(serialize = false, deserialize = false) private String email; // 构造函数、Getter、Setter 省略 } 在上述代码片段中，我们用 @Expose 标注了 name 和 age 字段。未显式设置 serialize 和 deserialize 属性意味着它们默认为 true。 https://springdoc.cn/java-jvm-arguments-prefixes/ Fri, 13 Jun 2025 09:53:17 +0800 https://springdoc.cn/java-jvm-arguments-prefixes/ 1、概览 Java 虚拟机（JVM）是驱动 Java 应用的核心引擎，负责执行编译后的 .class 文件，并通过即时编译（JIT）和垃圾回收（GC）等技术管理内存并提升性能。 JVM 具有高度灵活性，通过特定参数可轻松调整其行为以提升性能、排查问题或启用实验性功能。本文将带你了解用于配置 JVM 的不同参数前缀。 2、JVM 参数是什么？ JVM 参数是能改变虚拟机行为的特殊命令行选项，用于控制内存设置、性能调优、调试监控开关、垃圾回收配置及实验性功能。 启动 JVM 时可通过以下方式指定这些参数： java -Xmx512m -Denv=prod -verbose:gc -XX:+UseG1GC -jar App.jar 上述命令中使用了多种参数前缀，每个前缀标识了不同的配置类型。 -Xmx512m - 设置最大堆内存为 512 MB（非标准参数） -Denv=prod - 定义名为 env、值为 prod 的系统属性（System Property） -verbose:gc - 启用垃圾回收日志记录（标准参数） -XX:+UseG1GC - 指定 JVM 使用 G1 垃圾回收器（高级参数） 下面详细解析各类参数前缀的作用。 3、不同的 JVM 参数前缀 3.1、System Properties (-D) 系统属性（System Properties）通常用于配置 JVM 特定参数，如文件编码、用户目录、JVM 版本等 Java 相关配置。 通过 -D 命令行参数可定义键值对形式的系统属性，例如： java -Denv=prod -jar App.jar 在 -D 参数前缀中，字母 D 代表 Define（定义）。Java 为避免歧义未使用其他字母，该前缀简短、直观且易记忆，明确表示正在定义属性。 https://springdoc.cn/java-sanitize-html-prevent-xss-attacks/ Thu, 12 Jun 2025 11:29:24 +0800 https://springdoc.cn/java-sanitize-html-prevent-xss-attacks/ 1、简介 跨站脚本攻击（XSS）是一种安全漏洞，允许攻击者向网页应用中注入恶意脚本。这些脚本能在用户浏览器中执行，导致数据窃取、会话劫持或页面篡改等风险。 本文将带你了解如何在 Java 应用中过滤 HTML 输入以防止 XSS 攻击。 2、项目设置 首先，需要在 pom.xml 中添加 OWASP Java HTML sanitizer 库： <dependency> <groupId>com.googlecode.owasp-java-html-sanitizer</groupId> <artifactId>owasp-java-html-sanitizer</artifactId> <version>20240325.1</version> </dependency> 该库提供高度可配置的策略驱动式 Sanitizer（净化器），既能处理复杂 HTML 内容，又能有效防御 XSS 攻击。 3、实现基础版 OWASP HTML 过滤 添加依赖后，我们定义一个工具方法，利用该库清理可能非法的 HTML 输入。 以下创建了一个可复用的工具类，采用默认策略（仅允许基础格式化标签）实现 HTML 过滤： public class HtmlSanitizerUtil { private static final PolicyFactory POLICY = Sanitizers.FORMATTING.and(Sanitizers.LINKS); public static String sanitize(String htmlContent) { return POLICY.sanitize(htmlContent); } } 上例中，我们通过组合两个内置 Sanitizer（Sanitizers.FORMATTING 和 Sanitizers.LINKS）配置过滤策略。该策略允许基础 HTML 格式化标签（如 <b>、<i>、<u>）以及通过 <a> 标签实现的超链接。随后 sanitize() 方法将此策略应用于输入字符串，返回过滤后的 HTML 内容。 https://springdoc.cn/mapstruct-nested-mapping/ Thu, 12 Jun 2025 10:16:16 +0800 https://springdoc.cn/mapstruct-nested-mapping/ 1、概览 MapStruct 通过注解来定义 POJO 属性间的映射关系。其 Maven 插件会读取注解中定义的元数据，自动生成 Mapper 工具类。此外，它还支持通过自定义映射工具实现细粒度控制。 本文将带你了解如何用 MapStruct 将层次化的源实体嵌套属性映射到扁平化的目标实体 2、用例 类体系图如下。通过源实体 Order 和目标实体 OrderDto 来演示 MapStruct 库执行嵌套映射的能力： 源实体 Order 表示具有嵌套结构的复杂对象，包含 Customer 和 Product： public class Order { private Customer customer; private Product product; // Getter/Setter 省略 } public class Customer { private String name; private Address address; // Getter/Setter 省略 } public class Product { private String name; private double price; // Getter/Setter 省略 } 此外，Customer 实体具有一个类型为 Address 的 address 属性： https://springdoc.cn/hibernate-fix-duplicatemappingexception/ Wed, 11 Jun 2025 10:20:51 +0800 https://springdoc.cn/hibernate-fix-duplicatemappingexception/ 1、概览 本文将带你了解如何处理 Hibernate 异常 “DuplicateMappingException: Column is duplicated in mapping for entity”。 2、理解 DuplicateMappingException 简而言之，DuplicateMappingException 是 MappingException 的子类，专门用于处理重复的对象关系映射错误。 当实体类中多次映射同一列时，会出现 “Column is duplicated in mapping for entity” 的提示信息。这种情况下，Hibernate 无法处理这种重复映射。 3、重现 DuplicateMappingException 了解了导致 Hibernate 抛出 DuplicateMappingException 的原因后，让我们通过实践来复现这个问题。 首先，定义一个 Person 实体类： @Entity public class Person { @Id private int id; @Column(name = "first_name") private String firstName; @Column(name = "first_name") // 重复定义了 first_name 列 private String lastName; // 省略 Getter/Setter } 简而言之，一个 person 由 id、firstName 和 lastName 组成。@Entity 注解表明 Person 类是一个 JPA 实体，而 @Id 注解表示主键。此外，@Column 注解将每个实体字段映射到特定的表列。 https://springdoc.cn/docker-compose-keep-container-running/ Wed, 11 Jun 2025 09:38:52 +0800 https://springdoc.cn/docker-compose-keep-container-running/ 1、概览 一个 Docker 容器会运行一个进程、应用程序，有时仅是一个脚本或命令，以执行其设计任务。 每个容器一旦内部没有任何进程或脚本运行，就会停止并退出。有些容器默认会持续运行，直到用户选择停止它们，例如 MySQL 数据库容器、Spring Boot Web 应用容器或 SMTP 邮件服务器容器。但有时，我们需要让容器在其主要任务完成后仍然保持运行，比如 Ubuntu 容器。 本文将带你了解如何使用 Docker Compose 实现这一需求。 2、Docker Compose 设置 Docker Compose 是我们用来定义和运行多容器服务的工具。唯一的前提条件是在受支持的操作系统平台上安装 Docker（包括 Docker Server、Docker Client 和 Docker Compose）。 本教程中我们使用 Linux Ubuntu。 3、运行 Ubuntu 容器 我们使用一个名为 docker-compose.yml 的示例 Docker Compose 配置文件来定义服务： services: demo: image: ubuntu 3.1、启动 Docker Compose 服务 使用 -d 选项在后台运行服务的容器： $ docker-compose up -d 输出如下，显示它创建了一个容器： Creating ubuntu_demo_1 ... done 查看 Docker Compose 服务创建的容器是否正在运行。 使用 docker ps -a 命令列出容器： https://springdoc.cn/spring-jdbc-incorrectresultsetcolumncountexception/ Tue, 10 Jun 2025 10:47:49 +0800 https://springdoc.cn/spring-jdbc-incorrectresultsetcolumncountexception/ 1、概览 使用 Spring 的 JdbcTemplate 时，若需将查询结果转换为 POJO 列表，常会遇到 IncorrectResultSetColumnCountException 异常。 该异常通常因误用 queryForList() 方法引发，特别是尝试将其直接映射到自定义 POJO 类时。 本文将带你了解异常成因、queryForList() 的正确用法，以及如何将查询结果映射到自定义类。 2、理解异常 假设存在 STUDENT_TBL 数据表，其中包含四名学生数据： CREATE TABLE STUDENT_TBL ( ID int NOT NULL PRIMARY KEY, NAME varchar(255), MAJOR varchar(255) ); INSERT INTO STUDENT_TBL VALUES (1, 'Kai', 'Computer Science'); INSERT INTO STUDENT_TBL VALUES (2, 'Eric', 'Computer Science'); INSERT INTO STUDENT_TBL VALUES (3, 'Kevin', 'Banking'); INSERT INTO STUDENT_TBL VALUES (4, 'Liam', 'Law'); 同时创建 Student POJO 类： https://springdoc.cn/java-postgresql-listen-notify-events/ Tue, 10 Jun 2025 09:47:36 +0800 https://springdoc.cn/java-postgresql-listen-notify-events/ 1、简介 本文将带你了解 PostgreSQL 中的 LISTEN 和 NOTIFY 命令，包括其功能、使用方法以及在应用中的实际应用。 2、LISTEN 和 NOTIFY 是什么？ PostgreSQL 支持使用 LISTEN 和 NOTIFY 命令在服务器和连接的客户端之间进行异步通信。这些特定于 PostgreSQL 的扩展使我们能够将数据库用作一个简单的 MQ 系统，允许我们从数据库中生成客户端可以做出反应的事件。这在很多方面都很有用，如实时仪表盘、缓存失效、数据审计等。 2.1、监听通知 使用 LISTEN 命令注册接收事件的监听，需指定目标频道名称： postgres=# LISTEN my_channel; LISTEN 完成注册后，该连接即可接收该频道的异步事件通知。 所有注册监听的连接都会收到通知，因此该系统实际采用广播机制而非单播。这意味着可通过此方式轻松向所有客户端同步数据库内发生的事件。 注意：若使用 psql 工具，不会自动接收通知。需重新执行 LISTEN 命令，此时会显示自上次监听后触发的所有通知： postgres=# LISTEN my_channel; LISTEN ..... postgres=# LISTEN my_channel; LISTEN Asynchronous notification "my_channel" with payload "Hello, World!" received from server process with PID 66. 此处可见某连接触发了 Payload 为 “Hello, world!” 的事件，监听连接已收到通知。 虽然监听器数量无硬性上限，但每个监听器需保持数据库连接开启以接收通知，因此实际受限于最大连接数限制。此外，每个监听器都会占用资源，过多监听器可能导致性能问题。 2.2、发布通知 了解如何监听事件后，还需掌握如何触发事件。使用 NOTIFY 命令可触发事件，需指定频道名称和发送的消息： https://springdoc.cn/spring-cloud-2025-0-0-is-abvailable/ Sat, 31 May 2025 19:51:00 +0800 https://springdoc.cn/spring-cloud-2025-0-0-is-abvailable/ Spring Cloud 2025.0.0 于 2025-05-29 正式发布。你可以在 Maven Central 中找到该版本。你可以查看 2025.0.0 发布说明 了解更多信息。 2025.0.0 中的显要变化 此版本兼容 Spring Boot 3.5.0。点击 此处 查看该版本中的所有问题和 PR。以下是 GA 发布前所有里程碑的亮点。 Spring Cloud Gateway 添加对 spring-cloud-function 和 spring-cloud-stream handler 的支持 #3646。 在服务器 webflux 中添加对 Bucket4jRateLimiter 的支持 #2955。 弃用 WebClientRouting 基础架构。这将在今年晚些时候的 5.0 中删除 #3680 创建了新的模块和 Starter 名称，旧名称已被弃用。#3645 的下表列出了新的和废弃的构件。这些新名称明确了网关的两种样式（Server 或 Proxy Exchange）以及 Spring 的两种 Web 技术栈（Web MCV 和 WebFlux）。使用过时的工件将在日志中添加警告信息。 已废弃 Artifact 新的 Artifact spring-cloud-gateway-server spring-cloud-gateway-server-webflux spring-cloud-gateway-server-mvc spring-cloud-gateway-server-webmvc spring-cloud-starter-gateway-server spring-cloud-starter-gateway-server-webflux spring-cloud-starter-gateway-server-mvc spring-cloud-starter-gateway-server-webmvc spring-cloud-gateway-mvc spring-cloud-gateway-proxyexchange-webmvc spring-cloud-gateway-webflux spring-cloud-gateway-proxyexchange-webflux 迁移到新的属性前缀，以匹配新的模块名称：#3361、#3362、#3363、#3647。使用 spring-boot-properties-migrator 支持已废弃的前缀。下表列出了模块或 Starter、其旧前缀和新替换前缀。 https://springdoc.cn/spring-ai-1-0-ga-released/ Wed, 21 May 2025 13:37:13 +0800 https://springdoc.cn/spring-ai-1-0-ga-released/ Spring AI 1.0 正式发布。 快速开始 构件已经发布到 maven central，可以通过提供的 bom 导入依赖项。 <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-bom</artifactId> <version>1.0.0</version>0 <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> 请查看 升级说明，了解最新的更改和升级方法。注意：你可以使用 OpenRewrite Recipe 自动升级到 1.0.0-GA。这可帮助应用此版本的许多必要代码更改。可在 Arconia Spring AI Migrations 查找使用说明。 你可以在 Intialzr 网站上开始创建 1.0 GA 应用，并阅读参考文档中的 “入门” 部分。 博客 这有一些博客精选，这些博客展示了如何以各种方式使用 Spring AI： 微软 Azure 博客 和 视频。特别感谢 Asir Selvasingh，他在 2023 年拉斯维加斯 Spring One 大会上帮助我们 发布了 Spring AI AWS - 博客 - Spring AI 1.0 为广大开发人员带来人工智能技术 Google - 博客 - Google Cloud 和 Spring AI 1. https://springdoc.cn/spring-aop-method-call-within-same-class/ Wed, 21 May 2025 11:27:16 +0800 https://springdoc.cn/spring-aop-method-call-within-same-class/ 1、概览 在使用 Spring AOP 时有许多错综复杂的问题。其中一个常见问题是如何处理同一类中的方法调用，因为这种直接调用会使 AOP 功能失效。 本文将带你了解 Spring AOP 的工作原理以及如何解决同类中 AOP 方法直接调用导致的 AOP 功能失效的问题。 2、代理 和 Spring AOP 代理对象可以看作是一个 “包装”，它可以在调用目标对象时添加功能。 在 Spring 中，当一个 Bean 需要额外功能时，就会创建一个代理，并将代理注入到其他 Bean 中。例如，如果某个方法具有事务（Transactional）注解或任何缓存注解，那么该代理就会被用来在调用目标对象时添加所需的功能。 3、AOP：内部方法调用和外部方法调用 如上所述，Spring 创建的代理添加了所需的 AOP 功能。 来看一个缓存示例，看看在内部和在外部调用方法有何不同： @Component @CacheConfig(cacheNames = "addOne") public class AddComponent { private int counter = 0; @Cacheable public int addOne(int n) { counter++; return n + 1; } @CacheEvict public void resetCache() { counter = 0; } } 当 Spring 创建 AddComponent Bean 时，也会创建一个代理对象，以添加用于缓存的 AOP 功能。当另一个对象需要 AddComponent Bean 时，Spring 会提供代理对象用于注入。 https://springdoc.cn/maven-output-version-number-text-file/ Tue, 20 May 2025 11:37:08 +0800 https://springdoc.cn/maven-output-version-number-text-file/ 1、概览 在基于 Maven 的 Java 项目中，经常需要将项目版本号输出到文本文件中。用于版本跟踪、日志记录以及确保不同构建和部署之间的一致性。 Maven 会在 pom.xml 文件中的 <version> 标签下维护项目版本。利用 Maven 的资源过滤（Resource Filtering）功能和附加插件，我们可以在构建过程中自动提取并存储该版本号。 本文将带你了解 Mave 实现版本号输出的两种方法：第一种是使用 Maven Resources Plugin，第二种是使用 Maven Antrun Plugin。 2、使用 Maven Resources Plugin Maven 资源插件通常用于文件过滤，允许用 pom.xml 中定义的值替换资源文件中的占位符。 该插件可以在构建过程中直接在资源文件中动态插入项目属性（version、artifactId、groupId）。 2.1、启用资源过滤 首先配置 pom.xml 文件中的 <resources> 部分，以启用项目中资源文件的过滤功能。 <build> <resources> <resource> <directory>src/main/resources</directory> <!-- 启用资源过滤 --> <filtering>true</filtering> </resource> </resources> </build> <filtering>true</filtering> 此配置会告诉 Maven 处理 src/main/resources 目录中的所有文件，并应用过滤功能，用 Maven 项目属性（如 ${project.version}）中的相应值替换任何占位符。 2.2、创建版本文件 接下来，在 src/main/resources 目录中创建一个资源文件（例如 version.txt）。该文件可包含 ${project.version} 等占位符，它们将在构建过程中被动态替换为 pom.xml 中定义的实际版本号。 如下，创建一个 version.txt 文件，内容如下： https://springdoc.cn/java-class-file-api/ Mon, 19 May 2025 10:29:32 +0800 https://springdoc.cn/java-class-file-api/ 1、简介 Java Class-File（类文件） API 是在 JEP-484 中引入的，是 Java 24 的一部分。它旨在创建一个接口，允许在不依赖于 ASM 库的传统 JDK 内部复制实现的情况下进行类文件处理。 本文将带你了解如何从头开始构建类文件，以及如何使用类文件 API 将一个类文件转换为另一个类文件。 2、 Class-File 核心的 API Class-File 有三个核心元素： 元素 - 代表代码的一部分，如变量、指令、方法或类。此外，一个元素可能包含其他元素。例如，一个类元素可能包含方法元素，而方法元素又包括变量或指令元素。 构建器 -（如方法构建器和代码构建器）用于创建每种类型的元素。 转换函数 - 可用于使用构建器将元素转换为其他元素。 3、生成类文件 使用 MethodBuilder 和 CodeBuilder 类生成类文件。 3.1、示例方法 先来看一个简单的代码段，它根据员工的角色和基本工资计算员工的工资： public double calculateAnnualBonus(double baseSalary, String role) { if (role.equals("sales")) { return baseSalary * 0.35; } if (role.equals("engineer")) { return baseSalary * 0.25; } return baseSalary * 0.15; } 3.2、使用 MethodBuilder 和 CodeBuilder 我们可以使用 MethodBuilder 和 CodeBuilder 类来生成与 calculateAnnualBonus() 功能相同的方法 https://springdoc.cn/java-protobuf-maps/ Mon, 19 May 2025 09:47:36 +0800 https://springdoc.cn/java-protobuf-maps/ 1、简介 ProtoBuf 为结构化数据的序列化提供了一种快速高效的方式，它是 JSON 的紧凑型高性能替代品。 与基于文本并需要解析的 JSON 不同，protobuf 可生成适用于多种语言的优化代码。这使得在不同系统间发送结构化数据变得更加容易。 使用 protobuf，只需在 .proto 文件中定义一次数据结构。然后，就可以使用生成的代码来处理跨流和跨平台的数据传输。在处理类型化、结构化数据时，它是理想的选择，尤其是当 Payload 比较大的时候。 Protobuf 支持字符串、整数、布尔值和浮点数等常见类型。它们还能很好地与 List 和 Map 配合使用，使复杂的数据易于管理。 本文将带你了解如何在 protobuf 中使用 Map。 2、了解 Protobuf 中的 Map 2.1、Map 是什么？ Map 是一种键值数据结构，类似于字典。 每个键都映射到一个特定的值，从而使查找快速高效。类似于 DNS 系统：每个域名都指向一个 IP 地址。 2.2、定义 Map 的语法 Protobuf 3 对 Map 提供了开箱即用的支持。 示例如下： message Dictionary { map<string, string> pairs = 1; } 使用 map<key_type, value_type> 定义字段。Key 必须是 scalar 类型，如 string、int32 或 bool。值可以是任何有效的 protobuf 类型 - scalar、enum 或其他消息。 https://springdoc.cn/spring-jdbc-jdbctemplate-guide/ Tue, 13 May 2025 09:41:16 +0800 https://springdoc.cn/spring-jdbc-jdbctemplate-guide/ 1、概览 本文将带你全面了解 Spring JDBC 模块。 Spring JDBC 中的所有类都分为四个独立的包： core — JDBC 的核心功能。该软件包下的一些重要类包括 JdbcTemplate、SimpleJdbcInsert、SimpleJdbcCall 和 NamedParameterJdbcTemplate。 datasource — 用于访问数据源的工具类。它还有各种数据源实现，用于在 Jakarta EE 容器外测试 JDBC 代码。 object — 以面向对象的方式访问数据库。它允许运行查询并将结果作为业务对象返回。它还能在业务对象的列和属性之间映射查询结果。 support — core 包和 object 包下的类的支持类，例如提供 SQLException 翻译功能。 2、Maven 依赖 在 pom.xml 中添加 spring-boot-starter-jdbc 和 mysql-connector-j： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> <version>3.3.5</version> </dependency> <dependency> <groupId>com.mysql</groupId> <artifactId>mysql-connector-j</artifactId> <version>9.1.0</version> </dependency> 然后，在 pom.xml 中添加 h2 依赖： <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.3.232</version> <scope>test</scope> </dependency> H2 数据库是一个嵌入式数据库，可用于快速原型开发。 3、配置 在 Spring 中配置数据源有两种主要方法：使用 properties 文件或使用基于 Java 的配置。 https://springdoc.cn/spring-validator-map/ Fri, 09 May 2025 09:36:27 +0800 https://springdoc.cn/spring-validator-map/ 1、简介 Spring 的 Validation 框架主要设计用于 JavaBean，其中每个字段都可以通过注解来定义验证约束。 本文将带你了解如何使用 Spring 的 Validator 接口验证 Map<String，String>。 2、理解问题 - Hibernate Validator 和 Map 在实现自定义验证器之前，我们会自然地尝试直接在 Map 结构上使用标准约束注解，通过 Hibernate Validator 和 Spring 内置的 @Valid 和 @Validated 等验证机制来进行校验。不幸的是，这种方法并不像我们想象的那样有效。 来看一个示例： Map<@Length(min = 10) String, @NotBlank String> givenMap = new HashMap<>(); givenMap.put("tooShort", ""); Validator validator = Validation.buildDefaultValidatorFactory().getValidator(); Set<ConstraintViolation<Map<String, String>>> violations = validator.validate(givenMap); Assertions.assertThat(violations).isNotEmpty(); // 测试失败 尽管在 Map 泛型上添加了约束注解，但校验结果 violations 仍是空的，即未检测到违反约束的情况。 2.1、为什么会校验失败？ Hibernate Validator 或一般的 Bean Validation 是根据 JavaBean 惯例运行的，这意味着它会验证通过 getter 访问的对象属性。由于 Map 不会将键和值作为属性公开，因此 像 @Length 或 @NotBlank 这样的约束注解并不直接适用，在验证过程中会被忽略。 https://springdoc.cn/fix-mysql-can-not-find-driver-exception/ Wed, 07 May 2025 10:33:23 +0800 https://springdoc.cn/fix-mysql-can-not-find-driver-exception/ 1、简介 在 Spring Boot 中整合 MySQL 时，我们通常依赖 Spring Boot 的自动配置和 JDBC 支持来连接数据库。不过，遇到配置问题的情况并不少见，尤其是在使用 过时的依赖 时。其中一个异常就是： Cannot load driver class: com.mysql.jdbc.Driver 本文将带你了解出现 “Cannot load driver class: com.mysql.jdbc.Driver” 异常的原因以及解决办法。 2、理解原因 这个问题的根源在于使用了过时的 MySQL 驱动程序类。在早期版本的 MySQL JDBC 驱动程序 （Connector/J） 中，通常使用以下驱动程序类： spring.datasource.driver-class-name=com.mysql.jdbc.Driver 不过，从 MySQL Connector/J 8.0 开始，该类已被弃用并删除。更新后的驱动程序类是 com.mysql.cj.jdbc.Driver 如果在新版本的 MySQL 驱动程序中继续使用旧的类名，应用将无法启动，并出现 ClassNotFoundException 异常。 3、处理问题 要解决这个问题，需要更新 Spring Boot 配置和项目中使用的依赖。 3.1、使用正确的依赖 第一步是在 application.properties 或 application.yml 文件中新的驱动程序类替换旧的驱动程序类。 spring.datasource.url=jdbc:mysql://localhost:3306/mydb spring.datasource.username=root spring.datasource.password=secret # 新的驱动类 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 或者 application.yml 文件： spring: datasource: url: jdbc:mysql://localhost:3306/mydb username: root password: secret driver-class-name: com. https://springdoc.cn/java-compilation-compiler-api/ Wed, 07 May 2025 09:36:54 +0800 https://springdoc.cn/java-compilation-compiler-api/ 1、简介 在 Java 开发中，编译是防止语法错误、类型不匹配和其他可能导致项目失败的问题的第一道防线。传统的工作流程依赖于手动编译，而现代应用程序则需要动态编译检查。例如： 实时验证学生提交的代码的教育平台 在部署前对生成的代码片段进行编译的 CI/CD 流水线 动态编译用户自定义逻辑的低代码工具 热代码重载系统可即时重载开发人员所做的更改 创建 Java 插件 Java Compiler API 允许在 Java 应用程序中以编程式编译代码，从而实现上述应用场景。像 LeetCode 或 Codecademy 等平台可即时验证用户提交的代码。当用户点击 “运行” 时，后台会使用编译器 API 等工具编译代码段、检查错误并在沙盒环境中执行。程序化编译为这一即时反馈循环提供了动力。 本文将带你了解 Java Compiler 这一强大的工具。 2、Java Compiler API 概览 Java Compiler API 位于 javax.tools 包内，提供对 Java 编译器的编程式访问。该 API 对于需要在运行时验证或执行代码的动态编译任务至关重要。 Compiler API 的主要组件包括： JavaCompiler：启动编译任务的主编译器实例 JavaFileObject：代表 Java 源文件或类文件，可以是内存文件，也可以是基于文件的文件 StandardJavaFileManager：编译过程中管理输入和输出文件 DiagnosticCollector：捕获错误和警告等编译诊断信息 这些组件协同工作，可在 Java 应用程序中实现灵活高效的动态编译。 3、实现编译 JDK 环境默认提供 Compiler API，无需任何外部依赖。 现在，来看看如何编译内存中的 Java 代码。 3.1、在内存中创建源码 首先在内存中创建一个 Java 源码类： // 继承自 SimpleJavaFileObject public class InMemoryJavaFile extends SimpleJavaFileObject { private final String code; protected InMemoryJavaFile(String name, String code) { super(URI. https://springdoc.cn/spring-ai-extract-data-from-images/ Wed, 30 Apr 2025 10:14:10 +0800 https://springdoc.cn/spring-ai-extract-data-from-images/ 1、概览 本文将带你了解如何使用 Spring AI 通过 OpenAI 聊天模型从图像中提取结构化数据。 OpenAI 聊天模型可以分析上传的图像并返回相关信息。它还能返回结构化的输出结果，这些输出结果可以很容易地通过管道输送到其他应用程序，以进行进一步操作。 举例说明，我们要创建一个 Web 服务，接收客户端上传的图像并将其发送给 OpenAI，以计算图像中彩色汽车的数量。Web 服务会以 JSON 格式返回颜色数量。 2、Spring Boot 配置 在 Maven pom.xml 中添加以下 Spring Boot Start Web 和 Spring AI Model OpenAI 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>3.4.1</version> </dependency> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-openai-spring-boot-starter</artifactId> <version>1.0.0-M6</version> </dependency> 在 Spring Boot application.yml 文件中，必须要提供用于验证 OpenAI API 的 API 密钥（spring.ai.openai.api-key）和能够执行图像分析的聊天模型（spring.ai.openai.chat.options.model）的配置。 有多种支持图像分析的 模型，如 gpt-4o-mini、gpt-4o 和 gpt-4.5-preview。像 gpt-4o 这样的大模型知识面较广，但成本较高，而像 gpt-4o-mini 这样的小型模型成本较低，延迟也较小。我们可以根据自己的需求来选择型号。 本文选择使用 gpt-4o 模型： spring: ai: openai: api-key: "<YOUR-API-KEY>" chat: options: model: "gpt-4o" 配置完毕后，Spring Boot 就会自动加载 OpenAiAutoConfiguration 以注册 ChatClient 等 Bean。 https://springdoc.cn/java-program-background/ Wed, 30 Apr 2025 09:41:26 +0800 https://springdoc.cn/java-program-background/ 1、简介 有时，我们需要在后台运行 Java 程序，即在 SSH 终端关闭后还能继续运行。 2、将 Java 作为后台进程运行 在后台运行 Java 程序的最简单方法之一是在 shell 脚本中使用 & 操作符： #!/bin/sh java -jar /web/server.jar & echo $! > startupApp.pid 最后的 & 可确保进程在后台运行，而 echo $! > startupApp.pid 的作用是获取最后执行的后台命令的 PID（进程 ID），并且重定向输出到 startupApp.pid 文件中。该 PID 可唯一标识运行中的进程，以后可用于进程管理任务，如监控或停止进程。 不过，这种方法有一个缺点。如果我们断开了 SSH 会话，进程仍可能被终止，这会导致后台程序意外停止。 此外，由于进程不是作为服务来管理的，因此更难对其进行正确控制。我们无法像使用 systemd 等正规服务管理器那样轻松查看日志或启动/停止进程。 3、利用 Nohup 保活进程 如果想在断开 SSH 会话后还让后台进程继续执行，那么 nohup 就可以解决这个问题。nohup（不挂起）可以让进程在关闭会话或终端后继续运行。 nohup 用法如下： nohup java -jar /web/server.jar > output.log 2>&1 & echo $! > startupApp.pid nohup 会让进程继续运行，即使关闭了终端会话。> output.log 2>&1 表示将标准输出和错误输出重定向到一个名为 output. https://springdoc.cn/spring-boot-3-4-5-release-notes/ Fri, 25 Apr 2025 13:20:42 +0800 https://springdoc.cn/spring-boot-3-4-5-release-notes/ 🐞 Bug 修复 由于目录权限问题，使用原生镜像容器映像在 podman 上构建 Spring Boot 失败 #45256 Neo4jReactiveDataAutoConfiguration 假定某些 Bean 可用 #45235 使用空数据库名称时出现错误的 jOOQ 异常翻译 #45219 MessageSourceMessageInterpolator 不会在 message 与其 code 匹配时替换参数 #45213 IntegrationMbeanExporter 不符合由所有 BeanPostProcessors 处理的条件，使用 JMX 时会显示警告 #45194 OAuth2AuthorizationServerJwtAutoConfiguration 错误地使用了 @ConditionalOnClass #45178 MongoDB 的依赖管理缺少 Kotlin coroutine 驱动模块 #45159 ImagePlatform 可能导致 “OS must not be empty” 的 IllegalArgumentException #45153 TypeUtils 无法处理不同位置上名称相同的泛型 #45039 HttpClient 5 5.4.3 会中断本地 Docker transport #45028 不能使用 spring.datasource.hikari.data-source-class-name，因为驱动程序类名总是必需的，而 Hikari 不同时接受这两个名称。 #45002 如果 JDBC URL 用于未知驱动程序，则应用自定义 JdbcConnectionDetails 的后处理会在 Hikari 中触发 NPE #44998 在 Hikari 中，当尝试使用未知驱动程序的 JDBC URL 构建数据源时，DataSourceBuilder 会触发 NPE。 #44995 SSL 配置不监控链接文件的更改 #44887 EmbeddedLdapAutoConfiguration 不应依赖于 PreDestroy #44874 DataSourceTransactionManagerAutoConfiguration 应在 DataSourceAutoConfiguration 之后运行 #44819 JsonValueWriter 会对深度嵌套的项目抛出 StackOverflowError 错误#44627 在响应式 web 应用中，如果不使用 ‘file:’ 前缀，SslBundle 将无法打开 store 文件位置 #44535 使用结构化日志记录 Path 对象抛出 StackOverflowError #44507 📔 文档 将 @Component 设为 javadoc 链接 #45258 修复指向 buildpacks. https://springdoc.cn/spring-boot-enableeurekaclient-vs-enablediscoveryclient/ Fri, 25 Apr 2025 10:56:25 +0800 https://springdoc.cn/spring-boot-enableeurekaclient-vs-enablediscoveryclient/ 1、简介 本文将带你了解 @EnableEurekaClient 与 @EnableDiscoveryClient 的区别。 这俩注解在 Spring Cloud 微服务应用中，都用于客户端发现。 2、微服务中的服务注册 在以分布式和松散耦合为特点的微服务领域，随着服务数量的增加，维护准确的服务列表并确保它们之间的无缝通信变得越来越复杂。手动跟踪服务的健康状况和可用性是一项资源密集且容易出错的工作。这时，服务注册中心就变得非常有用。 服务注册中心是一个保存可用服务信息的数据库。它是服务注册、查询和管理的中心点。 当微服务启动时，它会在服务注册中心中注册自己。 3、@EnableDiscoveryClient 注解 @EnableDiscoveryClient 是 Spring Boot 提供的一种更通用的注解，使其成为服务发现的灵活选择。 可以将其视为一种约定，它允许我们的应用现在和将来与不同的服务注册中心协同工作。它包含在 spring-cloud-commons 依赖中，成为 Spring Cloud 服务发现机制的核心部分。 但是，它并不能独立工作，实际运行时需要真正的实现，如 Eureka、Consul 或 Zookeeper。 4、@EnableEurekaClient 注解 Eureka 最初由 Netflix 开发，提供了一个强大的服务发现解决方案。Eureka 客户端是 Eureka 的基本组成部分。 具体来说，应用可以作为客户端，在使用 Eureka 实现的服务注册中心注册。此外，Spring Cloud 还为其提供了一个抽象层，与 Spring Boot 结合使用，可大大简化 Eureka 与微服务架构的集成，从而提高开发人员的工作效率。 @EnableEurekaClient 注解在这一过程中起着至关重要的作用。更确切地说，它是作为客户端的服务向服务注册中心注册时使用的注解之一。 4.1、实现 Eureka Client 只有当 pom.xml 中包含 Eureka 客户端依赖 时，Eureka 客户端才能工作： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> </dependency> 还要定义 spring-cloud-commons <dependencyManagement>： <dependencyManagement> <dependencies> <dependency> <groupId>org. https://springdoc.cn/mybatis-plus-join-boot-starter-guides/ Thu, 24 Apr 2025 16:46:45 +0800 https://springdoc.cn/mybatis-plus-join-boot-starter-guides/ 功能特点 简化多表操作：MyBatis-Plus-Join 是 MyBatis-Plus 的扩展，让开发者能更便捷地进行多表关联查询、子查询等操作，通过简洁的API满足复杂查询需求。例如，在进行多表联合查询时，无需编写大量复杂的SQL语句或配置文件，只需简单配置和调用相关方法，即可实现多表数据的关联查询。 支持多种特性：支持列枚举、别名、逻辑删除、TypeHandle、一对一、一对多等功能，还支持 Lambda 和字符串两种查询方式，以及自定义字段映射和结果转换、动态条件构造和链式调用等高级特性。比如，在进行数据查询时，可以根据不同的条件动态构造查询语句，灵活地实现各种复杂的查询逻辑。 兼容性好：作为 MyBatis-Plus 的插件，它完全兼容 MyBatis-Plus 的使用习惯，引入后不会对现有工程产生影响，能与 MyBatis-Plus 原有功能无缝集成。 依赖配置 以Maven项目为例，在pom.xml文件中添加以下依赖即可使用： <dependency> <groupId>com.github.yulichang</groupId> <artifactId>mybatis-plus-join-boot-starter</artifactId> <version>1.5.3</version> </dependency> 最新版 MyBatis-Plus-Join 需要配合 MyBatis-Plus 3.1.2 及以上的版本使用。 代码示例 假设存在用户表 user 和订单表 order，它们之间通过 user_id 关联，以下是使用 mybatis-plus-join-boot-starter 进行多表查询的示例： import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.github.yulichang.base.MPJBaseMapper; import com.github.yulichang.wrapper.MPJLambdaWrapper; import com.example.demo.entity.User; import com.example.demo.entity.Order; import org.springframework.stereotype.Repository; import javax.annotation.Resource; import java.util.List; @Repository public class UserRepository { @Resource private MPJBaseMapper<User> userMapper; public List<User> getUserWithOrders() { // 使用MPJLambdaWrapper进行多表查询 MPJLambdaWrapper<User> wrapper = new MPJLambdaWrapper<User>() . https://springdoc.cn/spring-cloud-data-flow-commercial/ Tue, 22 Apr 2025 10:57:33 +0800 https://springdoc.cn/spring-cloud-data-flow-commercial/ TL;DR; 今天，官方宣布今后将不再以开源项目的形式维护 Spring Cloud Data Flow、Spring Cloud Deployer 或 Spring Statemachine。Spring Cloud Data Flow 2.11.x、Spring Cloud Deployer 2.9.x 和 Spring Statemachine 4.0.x 将是最后一批开源项目，今后的版本将仅提供给 Tanzu Spring 客户。这一变更不会影响 Spring 开源产品组合的其他部分，也不会影响现有用户对当前可用开放源码软件版本的支持义务。 Spring Cloud Data Flow 起源于八年前的 Spring XD，用于协调批处理和流工作负载，多年来在客户中取得了巨大成功。然而，为了让 Spring Cloud Data Flow 和相关生态系统项目在未来以可持续的方式发展下去，我们决定只将 Spring Cloud Data Flow 作为商业产品发布。 这一决定并不是轻易做出的，其主要原因是这些项目在我们的社区中得到了广泛采用。我们所看到的 Spring Cloud Data Flow 的绝大多数使用情况都发生在我们的 Tanzu 企业客户中。目前，开源应用只占总体应用的很小一部分，而社区提供的维护贡献同样很小。在过去的两年中，Spring Cloud Data Flow 的维护工作几乎完全由 Tanzu 的研发团队负责，而 Spring 产品组合中的绝大多数产品则由充满活力的社区以多种方式进行维护。Spring Statemachine 和 Spring Cloud Deployer 的采用模式与 Spring Cloud Data Flow 相似，它们的使用主要是由于 Spring Cloud Data Flow 中包含了 Spring Statemachine 和 Spring Cloud Deployer。 https://springdoc.cn/java-spring-webclient-set-headers/ Mon, 21 Apr 2025 11:40:21 +0800 https://springdoc.cn/java-spring-webclient-set-headers/ 1、简介 WebClient 是 Spring WebFlux 中的一个 HTTP 客户端工具类，可以实现同步和异步 HTTP 请求。 本文将带你了解在 Spring WebClient 中设置 Header 的几种方式。 2、WebClient 如何处理 Header？ 一般来说，HTTP 请求中的 Header 起到元数据的作用。它们包含认证详细信息、内容类型、版本等信息。 在 WebClient 中，HttpHeaders 类负责管理 Header。这是一个 Spring 框架类，专门用于表示请求和响应头。该类实现了 MultiValueMap<String, String>，允许一个 Header Key 有多个 Value。 这为需要多个值的 Header（如 Accept）提供了灵活性。 3、在 WebClient 中设置 Header 有几种方法可以为请求添加 Header。根据使用情况，我们可以为单个请求设置 Header，为整个 WebClient 实例定义全局 Header，或动态修改 Header。 3.1、为单个请求设置 Header 如果 Header 是针对单个请求的，并且因端点而异，那么直接的方法就是在请求中直接设置它们。 一个简单的示例如下。例化 WebClient，在请求中添加了两个 Header，并断言这些 Header 已通过请求发送。使用 okhttp3 库中的 MockWebServer 来模拟服务器响应并验证 WebClient 的行为： @Test public void givenRequestWithHeaders_whenSendingRequest_thenAssertHeadersAreSent() throws Exception { mockWebServer. https://springdoc.cn/spring-boot-enable-disable-embedded-tomcat/ Mon, 21 Apr 2025 10:46:22 +0800 https://springdoc.cn/spring-boot-enable-disable-embedded-tomcat/ 1、概览 默认情况下，Spring Boot 提供嵌入式 Tomcat 服务器，但在某些情况下，我们可能希望根据应用的需求来禁用/启用它。 对于不需要 Web 服务的 Spring Boot 应用，禁用 Tomcat 可以节省资源。 2、理解 Spring Boot 中的嵌入式 Tomcat Spring Boot 在应用的可执行 JAR 文件中捆绑了嵌入式 Tomcat 服务器，从而简化了应用的部署。这种方法消除了安装和配置外部 Tomcat 实例的需要，使开发和部署更加高效。 Spring Boot 使用 Spring Boot Starter 来包含嵌入式 Tomcat 的必要依赖。默认情况下， spring-boot-starter-web Starter 会在 Tomcat 出现在 classpath 中时自动配置和初始化 Tomcat。 2.1、嵌入式 Tomcat 的优势 Spring Boot 的嵌入式 Tomcat 服务器具有多种优势： 简化部署：无需安装外部 Tomcat 服务器。 独立的应用：应用程序可打包为 JAR 文件，在任何地方运行。 自动配置：Spring Boot 根据依赖自动配置 Tomcat。 灵活：可轻松替换为 Jetty 或 Undertow 等其他嵌入式服务器。 2.2、为什么要禁用 Tomcat 服务器？ 虽然嵌入式 Tomcat 很有用，但在某些情况下，禁用它对我们也有好处： https://springdoc.cn/java-datetimeparseexception-localdatetime-temporalaccessor/ Mon, 21 Apr 2025 10:07:50 +0800 https://springdoc.cn/java-datetimeparseexception-localdatetime-temporalaccessor/ 1、概览 在 Java 中使用 java.time 包处理日期和时间非常高效，但有时我们可能会遇到 DateTimeParseException 异常，提示 “Unable to obtain LocalDateTime from TemporalAccessor（无法从 TemporalAccessor 获取 LocalDateTime）”。出现这种问题的原因通常是预期的日期时间格式与实际输入不兼容。 本文将带你了解出现该异常的原因以及解决办法。 2、理解异常 当 Java 的日期时间解析器无法从 TemporalAccessor（如 LocalDate、ZonedDateTime 或 OffsetDateTime）中提取有效的 LocalDateTime 对象时，就会出现 “Unable to obtain LocalDateTime from TemporalAccessor” 异常。根本原因通常是输入字符串格式不当或不完整。 LocalDateTime 需要 日期 和 时间 两个部分。如果输入字符串缺少所需的部分或不符合预期的格式，解析过程就会失败，从而产生此异常。很多人认为 Java 可以自动推断缺少的时间值，但事实并非如此。 示例如下，解析一个日期字符串为 LocalDateTime 的错误例子： public static void main(String[] args) { String dateTimeStr = "20250327"; // 只有日期，没时间 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd"); LocalDateTime localDateTime = LocalDateTime.parse(dateTimeStr, formatter); } 执行该代码时，会出现以下异常： java.time.format.DateTimeParseException: Text '20250327' could not be parsed: Unable to obtain LocalDateTime from TemporalAccessor: {},ISO resolved to 2025-03-27 of type java. https://springdoc.cn/maven-predefined-properties/ Thu, 27 Mar 2025 10:44:53 +0800 https://springdoc.cn/maven-predefined-properties/ 1、简介 本文将带你了解 Maven 中的预定义属性。 2、Maven 预定义属性 Maven 有一些方便的内置属性，可以于简化配置。 如果需要，甚至可以直接在 pom.xml 文件中自定义它们。 这些属性也可以在任何由 Maven 资源插件的过滤功能处理的资源文件中使用，例如 application.properties 文件。在使用这些属性时，只需要将它们包装在 ${} 中。 2.1、使用示例 示例如下，使用输出目录位置属性： <?xml version="1.0" encoding="UTF-8"?> <project> <modelVersion>4.0.0</modelVersion> <groupId>example.override.properties</groupId> <artifactId>parameter-maven-plugin</artifactId> <version>1.0-SNAPSHOT</version> <packaging>maven-plugin</packaging> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-plugin-plugin</artifactId> <version>3.2</version> <configuration> <outputDirectory>${project.build.directory}</outputDirectory> </configuration> </plugin> </plugins> </build> </project> 上面的示例展示了如何获取 ${project.build.directory} 的默认值，即 src/main/resources。 2.2、属性覆盖示例 自定义构建路径的属性： <?xml version="1.0" encoding="UTF-8"?> <project> <modelVersion>4.0.0</modelVersion> <groupId>example.override.properties</groupId> <artifactId>parameter-maven-plugin</artifactId> <version>1.0-SNAPSHOT</version> <packaging>maven-plugin</packaging> <build> <directory>src/main/resources/custom</directory> </build> </project> 如上，通过在 <project> -> <build> -> <directory> 中指定自定义值，将 ${project.build.directory} 属性的默认值覆盖为 src/main/resources/custom。 https://springdoc.cn/spring-ai-update-to-snapshots/ Thu, 27 Mar 2025 10:10:25 +0800 https://springdoc.cn/spring-ai-update-to-snapshots/ Spring AI 1.0.0-SNAPSHOT 在构件 ID、依赖管理和自动配置方面引入了几项重要变更。 本文将带你了解这些变更并提供项目更新指南。 最显著的变更是 Spring AI Starter 构件的命名模式： 模型 starter：spring-ai-{model}-spring-boot-starter → spring-ai-starter-model-{model} 向量存储 starter：spring-ai-{store}-store-spring-boot-starter → spring-ai-starter-vector-store-{store} MCP starter：spring-ai-mcp-{type}-spring-boot-starter → spring-ai-starter-mcp-{type} 此外，你需要添加快照仓库并更新 Dependency Management （依赖管理）配置。 有两种方式可以将项目更新到 Spring AI 1.0.0-SNAPSHOT：使用 AI 工具自动更新 或 手动更新。自动方式利用 Claude Code 快速转换你的项目，而手动方式为那些喜欢直接进行更改的人提供了逐步说明。 使用 Claude Code 自动更新 对于偏好自动化方式的用户，你可以使用 Claude Code CLI 工具，通过提供的提示自动将项目升级到 1.0.0-SNAPSHOT。这种方法可以在升级多个项目或复杂代码库时节省时间并减少错误。更多详情，请参阅升级说明中的 使用 AI 自动升级 部分。 这里仅以屏幕截图的形式展示 Claude Code CLI 工具将执行的步骤。 更新 BOM 版本。 添加仓库。 更新 starter。 全部完成！ 手动更新 添加快照仓库 要使用 1.0.0-SNAPSHOT 版本，你需要在构建文件（pom.xml）中添加相应的快照仓库。其中，Central Sonatype Snapshots 仓库（https://central. https://springdoc.cn/java-jackson-fields-dynamic-ignore/ Thu, 20 Mar 2025 09:41:28 +0800 https://springdoc.cn/java-jackson-fields-dynamic-ignore/ 1、简介 本文将带你了解如何在 Jackson 中通过 @JsonFilter、@JsonView 和 Jackson Mixin（混合） 实现动态忽略字段。 2、项目设置 添加 Jackson 库： <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.17.2</version> </dependency> 最新版本可在 此处 找到。 3、使用 @JsonFilter 第一种方法是通过 @JsonFilter 注解指定在序列化过程中使用的过滤器。 使用 @JsonFilter 对类进行注解： @JsonFilter("publicFilter") // 指定 Filter 名称 public class UserWithFilter { private Long id; private String name; //Getter/Setter 忽略 } 然后，动态配置 ObjectMapper，并注册 PropertyFilter 来序列化除 id 之外的所有字段： SimpleFilterProvider filterProvider = new SimpleFilterProvider(); // 注册 Filter，指定名字 filterProvider.addFilter("publicFilter", SimpleBeanPropertyFilter.serializeAllExcept("id")); ObjectMapper objectMapper = new ObjectMapper().setFilterProvider(filterProvider); 然后，使用 objectMapper 序列化 UserWithFilter 对象： https://springdoc.cn/spring-boot-seamless-integration-deepseek-and-qw/ Wed, 19 Mar 2025 17:09:24 +0800 https://springdoc.cn/spring-boot-seamless-integration-deepseek-and-qw/ 本文将带你了解如何在 Spring Boot 中使用 spring-ai 无缝接入 DeepSeek 和通义千问来构建自己的 AI 应用。 Spring & JDK 版本： springboot 3.4.3 jdk17 1、maven依赖 <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-openai-spring-boot-starter</artifactId> </dependency> 2、application.yaml 配置 # DeepSeek 配置，完全兼容openai配置 # spring: # ai: # openai: # base-url: https://api.deepseek.com # DeepSeek的OpenAI式端点 # api-key: sk-xxxxxxxxx # chat.options: # model: deepseek-chat # 指定DeepSeek的模型名称 # 通义千问配置 spring: ai: openai: base-url: https://dashscope.aliyuncs.com/compatible-mode # 通义千问 api-key: sk-xxxxxxxxxxx chat.options: model: qwen-plus 3、Controller package org.example.springboot3ds.controller; import jakarta.annotation.PostConstruct; import jakarta.annotation.Resource; import org. https://springdoc.cn/null-safety-in-spring-apps-with-jspecify-and-null-away/ Tue, 18 Mar 2025 10:13:19 +0800 https://springdoc.cn/null-safety-in-spring-apps-with-jspecify-and-null-away/ Null Safety 旨在防止空指针（NullPointerException）异常。 最初在 Spring 中引入 Null Safety 支持要追溯到 2017 年发布的 Spring Framework 5.0。2025 年，我们会继续完善这一功能，为 Java 或 Kotlin 的 Spring 开发人员带来更多附加值。 我们要解决什么问题？ 举一个具体的例子，假设我们正在使用一个提供 TokenExtractor 接口的库，其定义如下： interface TokenExtractor { /** * Extract a token from a {@link String}. * @param input the input to process * @return the extracted token */ String extractToken(String input); } 如果由于某种原因实现返回 null 值，在 token.length() 中访问 null 引用（如下所示）会导致 NullPointerException 异常，通常会在运行时产生状态码为 500 Internal Server Error 的 HTTP 响应。 https://springdoc.cn/spring-boot-http2-tomcat/ Tue, 18 Mar 2025 09:51:00 +0800 https://springdoc.cn/spring-boot-http2-tomcat/ 1、概览 HTTP/2 是广泛使用的 HTTP/1.1 协议的后续协议，它通过采用多路复用和 Header 压缩等新功能提高了网络性能。 本文将带你了解如何配置 Spring Boot 应用，以在嵌入式 Tomcat 服务器上启用 HTTP/2。 2、HTTP/2 超文本传输协议（HTTP）是一种在互联网上获取资源的应用协议。HTTP/1.1 于 1997 年 1 月发布，二十多年来为大多数网络提供服务。该版本发现了在某些情况下导致性能缓慢的问题。 HTTP/2 克服了 HTTP/1.1 中的性能问题，具有以下特点： 多路复用 - HTTP/1.1 使用多个连接发送多个请求；多路复用允许通过单个连接发送请求，从而减少资源消耗和延迟 Header 压缩 - 如果不进行压缩，由于 TCP 启动速度较慢，通常需要多次往返才能发送 Header；压缩 Header 后，Header 的发送往返次数会减少，大部分时间都能在一次往返内完成 二进制 - 与使用文本编码数据的 HTTP/1.1 相比，HTTP/2 以二进制格式发送数据，以减少解析开销并缩小报文大小。 3、先决条件 HTTP/2 可以通过明文或 TLS 运行。大多数 Web 浏览器不支持明文 HTTP/2，因此建议通过 TLS 运行。 首先要在嵌入式 Web 服务器上启用 SSL。 在控制台中运行以下 keytool 命令来生成一个 keystore，用于存储 SSL/TLS 使用的密钥和证书，并将其放入嵌入式 Tomcat 中。 $ keytool -genkeypair -alias http2-alias -keyalg RSA -keysize 2048 -storetype PKCS12 -keystore keystore. https://springdoc.cn/java-google-translate-api/ Thu, 13 Mar 2025 10:26:35 +0800 https://springdoc.cn/java-google-translate-api/ 1、简介 本文将带你了解如何将 Google Translate API 集成到 Java 应用中，谷歌的翻译服务支持 100 多种语言，通过它的 API，我们可以轻松构建一个可以执行实时语言翻译的应用。 2、添加 SDK 依赖 首先，在 pom.xml 文件中添加 Google Cloud Translate 依赖： <dependency> <groupId>com.google.cloud</groupId> <artifactId>google-cloud-translate</artifactId> </dependency> Google Cloud Translate 提供了与 API 交互的简易接口。它会处理我们的应用与 Google 翻译服务之间的所有通信。 3、初始化 Translate 客户端 依赖添加后，下一步就是在 Java 应用中初始化 Translate 客户端。这需要使用从 Google Cloud Console 获取的服务帐户 JSON 文件进行身份验证。这种方法更安全，建议用于服务器端应用。 接下来，需要确保服务帐户已启用云翻译 API 并分配给 Google Cloud 中的云翻译 API 用户角色。 然后，通过 TranslateOptions 设置 API 凭证等配置，然后初始化 Translate 客户端： class Translator { static { initializeTranslateClient(); } public static void initializeTranslateClient() { if (translate == null) { try { GoogleCredentials credentials = GoogleCredentials. https://springdoc.cn/spring-security-deactivate/ Tue, 11 Mar 2025 11:04:55 +0800 https://springdoc.cn/spring-security-deactivate/ 1、概览 Spring Security 是一个功能强大、高度可定制的 Java 应用身份认证和访问控制框架。本文将带你了解 Spring Security 的基本概念，以及一些可能需要禁用它的常见场景，例如在 开发、测试 或 使用自定义安全机制 时。 2、禁用 Spring Security 我们可以通过多种方式禁用 Spring Security： 使用自定义安全（Security）配置 利用 Spring Profile 移除 Spring Security 依赖 排除 Spring Security 自动配置 先通过 Spring Initializr 创建一个基于 Maven 的最小 Spring Boot 项目，其中包含一个 Controller，作为我们的测试端点： @RestController @RequestMapping("/api") public class PublicController { @GetMapping("/endpoint") public ResponseEntity<String> publicEndpoint() { return ResponseEntity.ok("This is a public endpoint."); } } 3、使用自定义 Security 配置 禁用 Spring Security 的最直接方法之一就是创建自定义 Security 配置类。这种方法包括定义和配置 SecurityFilterChain Bean，以允许所有未经身份验证的请求： https://springdoc.cn/spring-ai-deepseek-cot/ Tue, 11 Mar 2025 09:59:26 +0800 https://springdoc.cn/spring-ai-deepseek-cot/ 1、概览 现代 Web 应用越来越多地与大型语言模型（LLM）集成，以构建解决方案。 DeepSeek 是一家中国的 AI 研究公司，致力于开发功能强大的 LLM，最近凭借其 DeepSeek-V3 和 DeepSeek-R1 模型颠覆了人工智能世界。DeepSeek-V3 和 DeepSeek-R1 模型揭示了它的思维链（CoT），让我们了解了 AI 模型是如何解释和处理给定提示的。 本文将带你了解如何将 DeepSeek 模型与 Spring AI 集成，以构建一个能够进行多轮文本对话的简单聊天机器人。 2、依赖和配置 有多种方法可以将 DeepSeek 模型集成到我们的应用中。 2.1、使用 OpenAI DeepSeek 模型与 OpenAI API 完全兼容，可以使用任何 OpenAI 客户端或库进行访问。 首先，在项目的 pom.xml 文件中添加 Spring AI 的 OpenAI Starter 依赖： <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-openai-spring-boot-starter</artifactId> <version>1.0.0-M6</version> </dependency> 由于当前的 1.0.0-M6 版本是里程碑版本，因此还需要在 pom.xml 中添加 Spring Milestones Repository： <repositories> <repository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/milestone</url> <snapshots> <enabled>false</enabled> </snapshots> </repository> </repositories> 该 Repository 是发布里程碑版本的地方，而不是标准的 Maven Central Repository。无论我们选择哪种配置选项，都需要添加这个里程碑 Repository。 https://springdoc.cn/java-jdk_java_options-vs-java_tool_options/ Wed, 05 Mar 2025 11:17:18 +0800 https://springdoc.cn/java-jdk_java_options-vs-java_tool_options/ 1、概览 在配置 Java 应用时，我们经常需要在不修改脚本的情况下传递 JVM 选项。 我们可以使用环境变量 JDK_JAVA_OPTIONS 或 JAVA_TOOL_OPTIONS，而不是每次运行 java 命令时都手动添加标记。这两个环境变量的作用相同：动态传递 JVM 选项，但它们的工作方式不同。 本文将带你了解它们的区别、何时使用每种配置以及有效管理 JVM 配置的最佳实践。 2、JDK_JAVA_OPTIONS 和 JAVA_TOOL_OPTIONS 是什么？ 这两个环境变量都允许我们在全局范围内指定 JVM 选项，从而省去了每次执行 JDK 工具（如 java、javac、javadoc 等）时修改选项的麻烦。 JAVA_TOOL_OPTIONS 在 Java 5 中引入。它们的行为和目的截然不同。 在深入了解每个环境变量的功能之前，先创建一个简单的 Java 源码文件： package com.baeldung; /** * 一个用于打印某些变量值的简单类 */ public class TestEnvVar { public static void main (String[] args){ System.out.println("var1 = '" + System.getProperty("var1") + "'"); System.out.println("var2 = '" + System.getProperty("var2") + "'"); } } 上面的代码非常简单。我们的 main() 方法会打印出 var1 和 var2 的值。稍后，我们将使用这两个环境变量把参数传递给这个类。 https://springdoc.cn/java-sasl/ Wed, 05 Mar 2025 09:48:28 +0800 https://springdoc.cn/java-sasl/ 1、概览 本文将带你了解 Simple Authentication and Security Layer（简单身份验证和安全层，SASL）的基础知识，以及如何在 Java 中使用 SASL 确保通信安全。 主要是使用 SASL 来确保客户端和服务端通信的安全。 2、SASL 是什么？ SASL 是互联网协议中的身份验证和数据安全框架。它旨在将互联网协议与特定的身份验证机制分离开来。 通信安全的需求是不言而喻的。从客户端和服务器通信的角度可以更好的理解这一点。客户端和服务器通常通过网络交换数据。双方必须相互信任并安全地发送数据。 2.1、SASL 的定位是什么？ 在应用中，我们可能使用 SMTP 发送电子邮件，使用 LDAP 访问目录服务。但每种协议都可能支持另一种身份验证机制，如 Digest-MD5 或 Kerberos。 如果有一种方法可以让协议以声明的方式交换身份验证机制，那会怎么样呢？这正是 SASL 的用武之地。支持 SASL 的协议总是可以支持任何一种 SASL 机制。 因此，应用可以协商一个合适的机制，并采用该机制进行身份验证和安全通信。 2.2、SASL 的原理是什么？ 了解了 SASL 在整个 安全通信 中的位置后，让我们来了解一下它是如何工作的。 SASL 是一种 challenge-response 框架。在这里，服务器向客户端发出 challenge，客户端根据 challenge 发送响应。challenge 和响应是任意长度的字节数组，因此可以携带任何特定机制的数据。 这种交换会持续多次，最后在服务器不再发出 exchange 时结束。 此外，客户端和服务器还可以在验证后协商一个安全层（Security Layer）。所有后续通信都可以利用这个安全层。不过，需要注意的是，有些机制可能只支持身份验证。 重要的是要明白，SASL 只提供了一个交换 exchange 和响应数据的框架。它没有提及任何有关数据本身或如何交换数据的内容。这些细节留给采用 SASL 的应用去处理。 3、Java 中的 SASL 支持 Java 中有一些 API，可支持使用 SASL 开发客户端和服务器端应用。API 并不依赖于实际机制本身。使用 Java SASL API 的应用可根据所需的安全功能选择一种机制。 https://springdoc.cn/spring-ai-pgvector-semantic-search/ Tue, 04 Mar 2025 10:20:54 +0800 https://springdoc.cn/spring-ai-pgvector-semantic-search/ 1、概览 搜索 是软件中的一个基本概念，目的是在大数据集中查找相关信息。它涉及在一系列项目中查找特定项目。 本文将带你了解如何使用 Spring AI、PGVector 和 Ollama 实现语义搜索。 2、基础概念 语义搜索是一种先进的搜索技术，它利用词语的含义来查找最相关的结果。要构建语义搜索应用，需要了解一些关键概念： 词嵌入（Word Embedding）：词嵌入是一种词表示类型，允许具有相似含义的单词具有类似的表示形式。词嵌入将单词转换为数值向量，可以在机器学习模型中使用。 语义相似性：语义相似性是衡量两段文本在意义上相似程度的一种方法。它用于比较单词、句子或文档的含义。 向量空间模型：向量空间模型是一种数学模型，用于将文本文档表示为高维空间中的向量。在该模型中，每个单词都表示为一个向量，两个单词之间的相似度根据它们向量之间的距离来计算。 余弦相似度：余弦相似度是内积空间中两个非零向量之间的相似度量，它测量的是两个向量之间角度的余弦值。它计算向量空间模型中两个向量之间的相似度。 3、先决条件 首先，我们需要在机器上安装 Docker，以便运行 PGVector 和 Ollama。 然后，在 Spring 应用中添加 Spring AI Ollama 和 PGVector 依赖： <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-ollama-spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-pgvector-store-spring-boot-starter</artifactId> </dependency> 还要添加 Spring Boot 的 Docker Compose 支持，以管理 Ollama 和 PGVector Docker 容器： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-docker-compose</artifactId> <version>3.1.1</version> </dependency> 除了依赖外，还要在 docker-compose.yml 文件中描述这两个服务： services: postgres: image: pgvector/pgvector:pg17 environment: POSTGRES_DB: vectordb POSTGRES_USER: postgres POSTGRES_PASSWORD: postgres ports: - "5434:5432" healthcheck: test: [ "CMD-SHELL", "pg_isready -U postgres" ] interval: 10s timeout: 5s retries: 5 ollama: image: ollama/ollama:latest ports: - "11435:11434" volumes: - ollama_data:/root/. https://springdoc.cn/java-jdbc-execute-multiple-statements/ Tue, 25 Feb 2025 10:30:44 +0800 https://springdoc.cn/java-jdbc-execute-multiple-statements/ 1、概览 在使用 Java 和 JDBC 处理数据库时，有时我们需要将多条 SQL 语句作为单个操作来执行。这可以提高应用性能、确保原子性或更有效地管理复杂的工作流。 本文将带你了解如何使用 Statement 对象、批处理和存储过程来演示如何高效执行多个 SQL 查询。 在本教程中，我们将使用 MySQL 作为数据库。 2、JDBC 和数据库设置 2.1、Maven 依赖 首先，在 pom.xml 中添加以下依赖项，以包含 MySQL JDBC 驱动： <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId <version>8.0.33</version> </dependency> 2.2、数据库配置 在本例中，我们要创建一个名为 user_db 的 MySQL 数据库和一个名为 users 的表，并为其执行多个 insert 查询： CREATE DATABASE user_db; USE user_db; CREATE TABLE users ( id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(50) NOT NULL, email VARCHAR(100) NOT NULL UNIQUE ); 数据库设置完毕后，我们就可以使用 JDBC 运行多条 SQL 语句了。 https://springdoc.cn/java-money-and-currency/ Tue, 25 Feb 2025 09:56:45 +0800 https://springdoc.cn/java-money-and-currency/ 1、概览 JSR 354 定义了 Java 中涉及 “货币和金钱” 的标准 API。 其目标是为 Java 生态系统添加一个灵活、可扩展的 API，使货币的处理更简单、更安全。 该 JSR 并未进入 JDK 9，但已成为未来 JDK 版本的候选。 2、设置 首先，在 pom.xml 中定义依赖： <dependency> <groupId>org.javamoney</groupId> <artifactId>moneta</artifactId> <version>1.1</version> </dependency> 最新版的依赖可以 这里 找到。 3、JSR-354 特性 货币 API 的目标是： 提供处理和计算货币金额的 API 定义表示货币和货币金额以及货币舍入的类 处理货币汇率 处理货币和金额的格式化和解析 4、Model JSR-354 规范的主要类如下图所示： Model 包含两个主要接口：货币单位（CurrencyUnit）和货币数量（MonetaryAmount），下文将对此进行解释。 5、CurrencyUnit CurrencyUnit 模拟了货币的最基本属性。可使用 Monetary.getCurrency 方法获取其实例： @Test public void givenCurrencyCode_whenString_thanExist() { CurrencyUnit usd = Monetary.getCurrency("USD"); assertNotNull(usd); assertEquals(usd.getCurrencyCode(), "USD"); assertEquals(usd.getNumericCode(), 840); assertEquals(usd.getDefaultFractionDigits(), 2); } 我们创建 CurrencyUnit 时使用的是货币的字符串表示法，如果使用不存在的货币代码创建货币会导致 UnknownCurrency 异常： https://springdoc.cn/java-jdbc-executequery-dml-error/ Wed, 19 Feb 2025 10:20:44 +0800 https://springdoc.cn/java-jdbc-executequery-dml-error/ 1、简介 本文将带你了解如何解决 JDBC 异常：“Cannot issue data manipulation statements with executeQuery()”。 在使用 JDBC 与数据库交互时，这个异常并不常见，但这个问题很容易解决。 2、理解异常 2.1、导致这个异常的原因 当我们尝试使用 executeQuery() 方法执行 INSERT、UPDATE 或 DELETE 语句时，就会出现错误 “Cannot issue data manipulation statements with executeQuery()” 异常。 Statement 或 PreparedStatement 对象中的 executeQuery() 方法专门用于处理 SELECT 查询。如果检查一下该方法的签名，就会发现它返回的是 ResultSet 实例，其中包含从数据库中获取的记录。 使用 Connector/J 连接 MySQL 时会出现这种异常，但其他数据库也执行相同的规则。在这种情况下，它们会以不同的错误信息抛出类似的错误。 需要注意的是，在较新版本的 MySQL Connector/J 中，该错误信息已略有更新。现在是这样： java.sql.SQLException: Statement.executeQuery() cannot issue statements that do not produce result sets. 2.2、导致该异常的场景 来看一个代码示例，以便更好地理解是什么触发了异常。如前所述，我们使用 MySQL 数据库。 首先，为示例创建一个简单的数据表： CREATE TABLE IF NOT EXISTS users ( id INT PRIMARY KEY AUTO_INCREMENT, username VARCHAR(50), email VARCHAR(50) ) 现在我们可以尝试执行一个非 SELECT 语句的查询。 https://springdoc.cn/java-run-class-within-war-cli/ Wed, 19 Feb 2025 09:55:56 +0800 https://springdoc.cn/java-run-class-within-war-cli/ 1、概览 WAR 文件是 Web 应用程序归档文件（Web Application Archive）或 Web 应用程序资源文件（Web Application Resource）的简称，用于存储 Java Web 应用程序的资源。WAR 将所有 Web 组件打包成一个单元。它包含 JAR 文件、JavaServer Page（JSP）、Java Servlet、Java 类文件、XML 文件、HTML 文件以及 Web 应用程序所需的其他资源。 本文将带你了解如何使用 CLI 调用在 WAR 文件中的类。 2、WAR 文件的结构 WAR 文件使用 .war 扩展名并打包 Web 应用程序，我们可以将其部署到任何 Servlet/JSP 容器上。 下面是一个典型的 WAR 文件结构布局示例： META-INF/ MANIFEST.MF WEB-INF/ web.xml jsp/ helloWorld.jsp classes/ com/baeldung/*.class application.properties static/ templates/ lib/ // third party *.jar files as libs index.html 内部有一个 META-INF 目录，在 MANIFEST.MF 中保存了有关 Web 存档的有用信息。META-INF 目录是私有的，外部无法访问。 https://springdoc.cn/java-fix-classcastexception-ljava-lang-object/ Wed, 19 Feb 2025 09:33:41 +0800 https://springdoc.cn/java-fix-classcastexception-ljava-lang-object/ 1、概览 在 Java 中，数组是语言的基本组成部分，它提供了一种结构化的方式来存储相同类型的多个值。然而，在使用数组和类型转换时，我们有时会遇到意想不到的运行时异常。 当我们试图将 Object[] 数组转换为特定数组类型（如 Integer[]）时，就会出现这样的问题。这会导致 ClassCastException 异常，这可能会让很多人感到困惑。 本文将带你了解出现这种异常的原因，从而了解 Java 数组的基本机制，并学习如何在代码中避免此类错误。 2、问题介绍 像往常一样，先通过一个例子来了解这个问题： Integer[] convertObjectArray() { Object[] objArray = new Object[3]; objArray[0] = 1; objArray[1] = 2; objArray[2] = 3; return (Integer[]) objArray; } 在上述方法中，我们在一个 Object[] 数组中插入了三个 int 值。由于 Object[] 数组只包含 Integer，我们尝试将其转换为 Integer[] 数组。 在测试中调用该方法，看看会发生什么： Exception ex = assertThrows(ClassCastException.class, () -> convertObjectArray()); LOG.error("The exception stacktrace:", ex); 可以看到，调用该方法会抛出 ClassCastException。在输出中，还可以看到异常的详细信息： java.lang.ClassCastException: class [Ljava.lang.Object; cannot be cast to class [Ljava.lang.Integer; ... at . https://springdoc.cn/java-spring-validate-value-list/ Tue, 11 Feb 2025 10:35:23 +0800 https://springdoc.cn/java-spring-validate-value-list/ 1、概览 在 Spring 中，可以通过内置工具和注解简化数据验证，使我们能够轻松实现强大的验证逻辑。 本文将带你了解如何在 Spring 中验证 List 类型的参数值。 2、在 Spring 中配置 Validation 要启用验证，需要在 pom.xml 中添加以下 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validation</artifactId> </dependency> 该依赖会自动将 Hibernate Validator 整合到我们的 Spring 应用程序中。 3、验证 List 中的每个元素 假设我们需要验证员工角色列表。每个角色都应以 ROLE_ 开头。 首先在 Employee DTO 类中添加一个 roles 变量： @NotEmpty(message = "Roles list cannot be empty") @Valid private List<@Pattern(regexp = "ROLE_[A-Z]+", message = "Each role must start with 'ROLE_' and contain uppercase letters only") String> roles; @NotEmpty 注解确保列表不是空的，而 @Pattern 注解则验证每个角色都符合指定的格式（正则）。 https://springdoc.cn/java-serversocket-simple-http-server/ Tue, 11 Feb 2025 10:07:19 +0800 https://springdoc.cn/java-serversocket-simple-http-server/ 1、概览 HTTP 服务器通常用于为发起请求的客户端提供资源。Java 中有一系列生产级 Web 服务器。 本文将带你了解如何使用 ServerSocket 类实现一个简单的 Web 服务器，从而了解 HTTP 服务器是如何工作的。注意，此服务器仅用于教学目的，不适合用于生产。 2、ServerSocket 基础 首先，服务器会监听客户端应用程序的连接。客户端应用程序可以是浏览器、其他程序、API 工具等。连接成功后，服务器会响应客户端连接，向客户端提供资源。 ServerSocket 类提供了在指定端口上创建服务器的方法。它使用 accept() 方法监听指定端口上的传入连接。 accept() 方法会阻塞，直到建立连接，并返回一个 Socket 实例。Socket 实例为服务器和客户端之间的通信提供了对输入和输出流的访问。 3、创建 ServerSocket 实例 首先，创建一个监听指定端口的 ServerSocket 对象： int port = 8080; ServerSocket serverSocket = new ServerSocket(port); 接着，使用 accept() 方法接受一个传入连接： while (true) { Socket clientSocket = serverSocket.accept(); // ... } 如上，使用 while 循环等待连接。然后，调用 ServerSocket 对象上的 accept() 方法来监听和接受连接。 连接建立后，该方法会返回一个 Socket 对象，允许服务器和客户端通过已建立的网络进行通信。 4、处理输入和输出 通常，服务器接收来自客户端的输入并发送适当的响应。我们可以使用 Socket 类的 getInputStream() 和 getOutputStream() 方法，通过提供流来读取和写入数据到客户端，从而进行通信。 https://springdoc.cn/java-execute-jar-file/ Tue, 11 Feb 2025 09:47:01 +0800 https://springdoc.cn/java-execute-jar-file/ 1、简介 在开发 Java 项目时，我们可能会遇到这样的情况：需要在 Java 程序中启动一个单独的进程运行外部 JAR（可执行 JAR）并查看输出，或者可能想要执行外部 JAR 中带有 main 方法的类文件。 2、运行可执行 JAR 可执行 JAR 是一种 JAR 文件类型，它包含一个设置了 Main-Class 属性的清单（manifest）文件。该属性指向应首先运行（使用 main 方法）的类文件。 我们可以使用 java -jar <example.jar> 命令从命令行运行该 JAR。也可以在 Java 程序中使用 ProcessBuilder 来实现类似的结果。 下面的代码演示了如何以编程式将可执行 JAR 作为单独进程运行，并在控制台中查看输出结果： @Test public void givenRunnableJar_whenExecuted_thenShouldRunSuccessfully() { Process process = null; try { String jarFile = new File(Objects.requireNonNull(getClass().getClassLoader() .getResource(RUNNABLE_JAR_PATH)) .toURI()).getAbsolutePath(); ProcessBuilder processBuilder = new ProcessBuilder("java", "-jar", jarFile); processBuilder.redirectErrorStream(true); process = processBuilder.start(); try (InputStream inputStream = process.getInputStream()) { byte[] output = inputStream. https://springdoc.cn/spring-boot-3-4-2-release-notes/ Fri, 24 Jan 2025 09:26:53 +0800 https://springdoc.cn/spring-boot-3-4-2-release-notes/ 🐞 Bug 修复 logging.structured.json.customizer 的属性元数据类型不正确 #43916 仅指定 logging.structured.gelf.host 时，GraylogExtendedLogFormatProperties 会抛出 NullPointerException 异常 #43863 结构化日志属性在 Native Image 中不起作用 #43862 当 ALLOW_EMPTY_PASSWORD=yes 时，ClickHouse 的 Docker Compose 支持不允许使用空密码 #43790 在 2.23 或更早版本中，docker compose ps 现在会因为未知的 --orphans flag 而失败 #43717 构建信息时间戳被截断为秒 #43617 用于 SSL 重载的 FileWatcher 不支持 Symlink #43604 BindableRuntimeHintsRegistrar 应处理 TypeNotPresentException #43600 使用 Log4J2 StatusLogger 时，CapturedOutput 为空 #43578 Spring Boot 3.4 与 Gson 2.1 不兼容 #43442 使用 JUnit 测试依赖 spring-boot-actuator-autoconfigure 但不依赖 org.junit.platform:junit-platform-launcher 的 Gradle 7. https://springdoc.cn/java-golang-invoke-function/ Tue, 21 Jan 2025 10:21:39 +0800 https://springdoc.cn/java-golang-invoke-function/ 1、简介 众所周知，Java 和 Go 是两种著名的编程语言，各自在不同的领域表现出色。Java 以其可移植性和广泛的生态系统而闻名，而 Go 则以其简洁性、性能和高效的并发处理而著称。在某些情况下，将两种语言的优势结合起来，可以开发出更强大、更高效的应用程序。 本文将带你了解如何利用 Java Native Access（JNA）库来弥合两种语言之间的差距，从而在不编写任何 C 代码的情况下从 Java 中调用 Go 函数。 2、用 JNA 架起 Java 和 Go 之间的桥梁 传统上，从 Java 调用本地代码需要用 C 语言编写 Java 本地接口（JNI）代码，这会增加复杂性和开销。然而，随着 Java Native Access（JNA）库的出现，可以直接从 Java 调用本地共享库，而无需深入研究 C 代码。这种方法简化了集成过程，允许开发人员在 Java 应用程序中无缝利用 Go 的功能。 要理解这种集成是如何工作的，首先，要了解 Java Native Access（JNA）库在连接 Java 和 Go 方面的作用。具体来说，JNA 提供了一种从 Java 代码调用本地共享库函数的直接方法。通过将 Go 代码编译到共享库中并导出必要的函数，Java 可以与 Go 函数进行交互，就像它们是自己生态系统的一部分一样。 本质上，这一过程包括编写 Go 函数，将其编译成共享库，然后使用 JNA 创建映射到这些函数的相应 Java 接口。 2、项目设置 首先，设置项目环境。这包括配置集成所需的构建工具和依赖项。在本例中，我们需要以下组件： Java Development Kit（JDK）：用于编译和运行 Java 代码。 Go 语言环境：用于编写和编译 Go 代码。 Java Native Access（JNA）库：作为 Maven 项目的一个依赖项包含在内。 构建工具：Maven 适用于 Java，Go 编译器适用于 Go 代码。 添加 JNA 库到 maven 依赖： https://springdoc.cn/java-classpath-include-jars/ Tue, 21 Jan 2025 10:00:47 +0800 https://springdoc.cn/java-classpath-include-jars/ 1、简介 在开发 Java 项目时，我们经常依赖外部库来开发应用。 本文将带你了解把这些第三方库作为 JAR 添加到 classpath 下的不同方法。 2、在命令行中使用 -cp 或 -classpath 选项 如果我们从命令行启动程序，那么可以在命令中指定 JAR 依赖： java -cp /path/to/jar/file.jar com.example.MyClass 如上，/path/to/jar/file.jar 是 JAR 文件的路径，com.example.MyClass 是要执行的类。 还可以添加多个 jar： java -cp "lib/jar1.jar:lib/jar2.jar" com.example.MyClass 3、在命令行中使用 CLASSPATH 在某些情况下，在同一台机器上运行的多个 Java 程序可能需要用同一个 JAR。 在这种情况下，我们可以在 macOS/Linux 中设置 CLASSPATH 环境变量，而不是在每条命令中指定 classpath： export CLASSPATH=/path/to/jar/file.jar Windows 系统的设置方法如下： set CLASSPATH=C:\path\to\jar\file.jar 设置 CLASSPATH 后，我们就可以直接运行 Java 程序，而无需指定 -classpath 选项。 注意，如果我们以这种方式设置 CLASSPATH，它只对该终端会话有效。一旦终端关闭，设置就会丢失。所以，我们可以将 classpath 添加到环境变量，使其永久有效。 4、在 MANIFEST.MF 文件中指定 Classpath 当我们创建一个独立可执行的应用时，最佳实践是将所有依赖的 JAR 都打包到一个 JAR 中。 https://springdoc.cn/jwt-deprecated-setsigningkey/ Tue, 21 Jan 2025 09:35:50 +0800 https://springdoc.cn/jwt-deprecated-setsigningkey/ 1、概览 Java JWT（JSON Web Token）库是一个用于创建、解析和验证 JWT Token 的工具。这些 Token 可确保 API 和 Web 应用的安全，是身份验证和授权的通用解决方案。 本文将带你了解如何使用更先进的 parserBuilder.setSigningKey() 方法替换该库中已废弃的 parser().setSigningKey() 方法，以及使用 JWT Parser Builder 解析和验证 JWT 的优势。 2、签名密钥是什么？ 签名密钥是 JWT Token 的关键要素。JWT Token 由三部分组成：Header、Payload 和签名。签名是通过使用秘钥或公钥/私钥对对 Header 和 Payload 进行签名来创建的。当 Token 发送到服务器时，签名密钥将用于验证签名，确保 Token 未被篡改。 在 Java JWT 库中，签名密钥是在 Token 验证过程中提供给解析器的。这可以确保 Token 的完整性，并使服务器能够信任其内容。 3、Jwts 类是什么？ Jwts 类是 Java JWT 库中的一个核心工具类。它是处理 JWT 的入口点。该类为我们提供了创建、解析和验证 JWT 的各种方法。例如，当我们要解析 JWT 时，首先要调用 Jwts.parserBuilder() 方法，该方法为我们提供了一个构建器，用于构建带有必要配置选项（如设置签名密钥）的解析器。 3.1、已废弃方法概述 有了上述理论后，来看看我们要替换的已废弃的 parser().setSigningKey() 方法： JwtParser parser = Jwts. https://springdoc.cn/java-rest-swagger-vs-hateoas/ Tue, 14 Jan 2025 10:38:55 +0800 https://springdoc.cn/java-rest-swagger-vs-hateoas/ 1、概览 设计 REST API 通常使用两种流行的方法：Swagger 和 HATEOAS。这两种方法都旨在使 API 更友好、更易懂，但遵循不同的范式。 本文将带你了解 Swagger 和 HATEOAS 的区别以及一些常见用例。 2、Swagger 是什么？ Swagger 是一套用于构建、记录和使用 REST API 的开源工具。它允许开发人员使用基于 OpenAPI Specification（OAS） 的 JSON 或 YAML 文件来描述其 API 的结构。 来看看 Swagger 的主要功能。 2.1、代码生成 有了 Swagger，我们可以自动生成交互式 API 文档、代码和客户端库。Swagger 还可以用各种编程语言创建服务器存根（Stub）和客户端 SDK，从而加快开发速度。 这是一种 API 优先的方法，它定义了需求与应用程序维护人员之间的契约。 开发人员可以使用 SwaggerHub 等工具，通过提供 Swagger 规范文件为不同的编程语言创建模板代码。 例如，来看看一个简单的 User 端点的 YAML 模板： openapi: 3.0.1 info: title: User API version: "1.0.0" description: API for managing users. paths: /users: get: summary: Get all users security: - bearerAuth: [] # 端点的安全设置 responses: '200': description: A list of users. https://springdoc.cn/hibernate-fix-queryparameterexception/ Tue, 14 Jan 2025 10:16:01 +0800 https://springdoc.cn/hibernate-fix-queryparameterexception/ 1、概览 本文将带你了解 Hibernate 出现 QueryParameterException: “no argument for ordinal parameter” 异常的原因以及解决办法。 2、理解异常 通常，Hibernate 会抛出 QueryParameterException 来提示查询参数出现问题。它表示指定的参数无效或未找到。 此外，“no argument for ordinal parameter（没有设置指定顺序的参数）” 消息表示 Hibernate 无法为定义的参数找到合适的参数。导致这种异常的常见原因是在 Hibernate 查询中忘记了为已定义的参数提供值。 3、实际案例 知道了 Hibernate 出现 QueryParameterException 异常的原因后，让我们通过一个实际的例子来看看如何重现它。 首先，来看看 Employee 实体类： @Entity public class Employee { @Id private int id; private String firstName; private String lastName; // 标准的 Getter 和 Setter } 如上，Employee 有 id、firstName 和 lastName 字段。 @Entity 注解用于指定 Employee 类是一个 JPA 实体，而 @Id 注解则标记了表示主键的字段。 https://springdoc.cn/error-class-file-has-wrong-version/ Thu, 09 Jan 2025 10:31:20 +0800 https://springdoc.cn/error-class-file-has-wrong-version/ 1、概览 在处理 Java 项目时，建立新项目或更新或添加依赖时常见的错误是 “class file has wrong version（类文件版本错误）”。 本文将带你了解出现这个错误的原因以及解决办法。 2、原因 要了解根本原因，我们需要更多地了解类文件。 每当我们编译 Java 代码时，都会为编译文件中包含的每个类创建一个 .class 文件。这些 .class 文件的部分元数据是一个版本号，该版本号与用于编译代码的 Java 当前主版本号相对应。 对于最常见的 Java 版本，这些类的版本号分别为：Java 21 = 65.0、Java 17 = 61.0、Java 11 = 55.0 和 Java 8 = 51.0。如果我们使用的是不同版本的 Java，可以根据需要加减一个版本号，从而计算出相应的类文件版本号。 在运行时，Java 会查看每个 .class 文件，并要求运行环境的版本号大于或等于编译 .class 文件时使用的版本号。这种版本号要求是出于 Java 的向后兼容性机制。也就是说，如果我们运行的是 Java 17 代码，我们就可以使用任何用 Java 17 或以前版本的 Java 编译的类文件。但是，如果我们遇到一个用 Java 21 编译的 .class 文件，就会遇到 “class file has wrong version 65.0, should be 61.0”（class 文件版本号错误，应为 61. https://springdoc.cn/spring-boot-circuit-breaker-vs-retry/ Thu, 09 Jan 2025 09:57:50 +0800 https://springdoc.cn/spring-boot-circuit-breaker-vs-retry/ 1、概览 在分布式系统和微服务架构中，优雅地处理故障对于保持系统可靠性和性能至关重要。断路器（Circuit Breaker，也称为熔断器）和重试（Retry）是有助于实现这一目标的两种基本弹性模式。虽然这两种模式都旨在提高系统的稳定性和可靠性，但它们的目的截然不同，适用于不同的场景。 本文将带你深入了解这些模式，包括它们的机制、用例以及在 Spring Boot 中使用 Resilience4j 实现的细节。 2、什么是重试？ 重试模式是一种简单而强大的机制，用于处理分布式系统中的瞬时故障。当操作失败时，重试模式会尝试多次执行相同的操作，希望临时问题能自行解决。 2.1、重试的主要特点 重试机制围绕特定属性展开，这些属性使重试机制能够有效处理瞬时问题，确保临时故障不会升级为重大问题： 重复尝试：核心理念是对失败的操作重新执行指定次数。 Backoff（回退）策略：这是一种高级的重试机制，其中包括退避策略，如指数退避，有助于避免对系统造成过大压力。 适用于临时故障：最适合处理间歇性网络问题、临时服务不可用或瞬间资源紧张的情况。 2.2、重试示例 来看一个使用 Resilience4j 实现重试机制的简单示例： @Test public void whenRetryWithExponentialBackoffIsUsed_thenItRetriesAndSucceeds() { IntervalFunction intervalFn = IntervalFunction.ofExponentialBackoff(1000, 2); RetryConfig retryConfig = RetryConfig.custom() .maxAttempts(5) .intervalFunction(intervalFn) .build(); Retry retry = Retry.of("paymentRetry", retryConfig); when(paymentService.process(1)).thenThrow(new RuntimeException("First Failure")) .thenThrow(new RuntimeException("Second Failure")) .thenReturn("Success"); Callable<String> decoratedCallable = Retry.decorateCallable( retry, () -> paymentService.processPayment(1) ); try { String result = decoratedCallable.call(); assertEquals("Success", result); } catch (Exception ignored) { } verify(paymentService, times(3)). https://springdoc.cn/java-objects-requirenonnull/ Mon, 06 Jan 2025 10:15:14 +0800 https://springdoc.cn/java-objects-requirenonnull/ 1、简介 NullPointerException（空指针异常）是 Java 最常见的异常之一。它发生在访问或与指向空（null）的引用变量交互时。验证对象非空（尤其是当它们是方法或构造函数中的参数时）对于确保代码的健壮性和可靠性非常重要。我们可以通过编写自己的 null 检查代码、使用第三方库或选择更方便的方法来实现这一点。 本文将带你了解 Java 中内置的一种灵活的解决方案 - Objects.requireNonNull()。 2、Null 值处理 简单回顾一下，有很多方法可以避免手动空值检查。我们可以从各种库中进行选择，而不是用 if 语句来封装我们的代码，这可能会导致错误和耗时。Spring、Lombok（@NonNull） 和 Uber 的 NullAway 就是其中的几种。 相反，如果我们想保持一致性，避免在代码库中引入额外的库，或者使用普通 Java，我们可以选择 Optional 类或 Objects 方法。虽然 Optional 可简化空值处理，但它往往会增加编码开销，并使简单用例的代码变得杂乱无章。由于它是一个独立的对象，因此也会消耗额外的内存。此外，Optional 只能将 NullPointerException 转换为 NoSuchElementException，即不能解决缺陷。 而，Objects 类提供了静态工具方法，可以更高效地处理对象。该类在 Java 7 中引入，并在 Java 8 和 Java 9 中多次更新，它还提供了在执行操作前验证条件的方法。 3、Objects.requireNonNull() 的优点 Objects 类通过提供一组 requireNonNull() 静态方法，简化了对 null 值的检查和处理。这些方法提供了一种简单明了的方法，可在使用前检查对象是否为空。 requireNonNull() 方法的主要目的是检查对象引用是否为空，如果为空，则抛出 NullPointerException 异常。通过明确抛出异常，我们传达了检查的意图，使代码更易于理解和维护。这也会告知开发人员和维护人员，该错误是故意的，这有助于防止随着时间的推移对行为进行无意的更改。 Objects 类是 java.util 包的一部分，因此无需外部库或依赖关系即可轻松访问。它的方法都有详细的文档说明，为开发人员提供了正确使用的明确指导。 4、使用案例 现在，来看看 requireNonNull() 方法的各种用例（包括其各种重载方法）。 这些方法允许在不同情况下处理空值，从简单的空值检查到带有自定义信息的更复杂的验证。 此外，还有两个方法支持默认值 - requireNonNullElse() 和 requireNonNullElseGet()。 https://springdoc.cn/spring-boot-structured-logging/ Mon, 06 Jan 2025 09:45:23 +0800 https://springdoc.cn/spring-boot-structured-logging/ 1、概览 日志是任何软件应用程序的基本功能。它通过记录错误、警告和其他事件，帮助跟踪应用程序在运行期间的行为。 默认情况下，Spring Boot 应用程序会生成非结构化、人类可读的日志。虽然这些日志对开发人员很有用，但它们不容易被日志聚合工具解析或分析。结构化日志解决了这一限制。 本文将带你了解如何使用 Spring Boot 3.4.0 版中引入的功能实现结构化日志。 2、Maven 依赖 首先，在 pom.xml 中添加 spring-boot-starter 来启动 Spring Boot 项目： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> <version>3.4.0</version> </dependency> 上述依赖为 Spring Boot 应用中的自动配置和日志记录提供了支持。 3、Spring Boot 默认的日志 以下是 Spring Boot 的默认日志： INFO 22059 --- [ main] c.b.s.StructuredLoggingApp : No active profile set, falling back to 1 default profile: "default" INFO 22059 --- [ main] c.b.s.StructuredLoggingApp : Started StructuredLoggingApp in 2.349 seconds (process running for 3.259) 虽然这些日志信息量很大，但却无法被 Elasticsearch 等工具轻松抓取或进行指标分析。JSON 等结构化日志格式通过标准化日志内容解决了这一问题。 https://springdoc.cn/spring-boot-3-4-1-release-notes/ Fri, 20 Dec 2024 09:58:34 +0800 https://springdoc.cn/spring-boot-3-4-1-release-notes/ 🐞 Bug 修复 当 Bundle name 为空字符串时，KafkaProperties 无法构建 SSL properties #43563 当属性解析抛出 ConversionFailedException 时，诊断功能很差 #43559 SpringApplicationShutdownHandlers 不按确定顺序运行 #43536 无法找到 @SpringBootConfiguration 导致误导性错误信息 #43507 如果上下文中有多个 ResourceHandlerRegistrationCustomizer Bean，则只使用其中一个 #43497 混合使用专用（dedicated）服务和共享（shared）服务时无法使用 Docker Compose 支持 #43472 Kafka dependency management 不包括 kafka-server 模块 #43454 当 ‘/_ping’ 调用失败并且版本应该修复时，Docker API 版本被错误地报告 #43452 从 KafkaProperties 建立生产者/消费者属性的方法在没有 SSL Bundle 的情况下不便使用 #43448 -Djarmode=tools 中的故障不会持续返回非零退出值 #43436 HttpComponentsClientHttpRequestFactoryBuilder 代替了现有的 defaultRequestConfigCustomizer，而不是对其进行添加 #43429 即使 imagePlatform 为空，spring-boot-maven-plugin 也会设置它 #43424 OnBeanCondition fails to match on annotations when using Scoped Proxies #43423 使用作用域（Scope）代理时，OnBeanCondition 无法与注解匹配 #43382 H2ConsoleAutoConfiguration 会导致提前初始化数据源 Bean #43359 接受大于 2GB 的数字进度 #43356 基于 Servlet 的 UserDetailsServiceAutoConfiguration 在响应式应用程序中处于活动状态 #43334 在 spring. https://springdoc.cn/spring-boot-olap-clickhouse-database/ Thu, 19 Dec 2024 11:24:03 +0800 https://springdoc.cn/spring-boot-olap-clickhouse-database/ 1、简介 通过使用联机分析处理（Online Analytical Processing，OLAP），企业可以深入了解当前的运营情况，并确定改进趋势。这通常是通过对汇总的业务数据进行复杂的分析来实现的。 ClickHouse 是一个开源的、列式 OLAP 数据库，因其出色的 性能 而大受欢迎。 本文将带你了解如何在 Spring Boot 中整合、使用 ClickHouse。 2、项目设置 在开始与 ClickHouse 数据库交互之前，我们需要添加一些 SDK 依赖，并正确配置我们的应用。 2.1、依赖 首先，在项目的 pom.xml 中添加必要的依赖： <dependency> <groupId>com.clickhouse</groupId> <artifactId>clickhouse-jdbc</artifactId> <version>0.7.1</version> </dependency> <dependency> <groupId>org.lz4</groupId> <artifactId>lz4-java</artifactId> <version>1.8.0</version> </dependency> clickhouse-jdbc 依赖提供了 JDBC API 的实现，使我们能够与 ClickHouse 数据库建立连接并进行交互。 默认情况下，ClickHouse 使用 LZ4 压缩来存储数据，为此我们添加了 lz4-java 依赖项。 2.2、使用 Flyway 定义数据表 接下来，定义数据库表，并对其执行操作。 使用 Flyway 来管理数据库迁移。这需要添加 flyway-core 和 flyway-database-clickhouse 依赖： <dependency> <groupId>org.flywaydb</groupId> <artifactId>flyway-core</artifactId> </dependency> <dependency> <groupId>org.flywaydb</groupId> <artifactId>flyway-database-clickhouse</artifactId> <version>10.16.3</version> </dependency> 将这些依赖添加到 pom.xml 之后，在 src/main/resources/db/migration 目录中创建一个名为 V001__create_table. https://springdoc.cn/java-spring-chain-dofilter/ Tue, 17 Dec 2024 10:35:59 +0800 https://springdoc.cn/java-spring-chain-dofilter/ 1、简介 本文将带你了解 Spring 中 chain.doFilter() 方法的作用。 2、什么是 Spring Filter 在 Spring 应用中，Filter 过滤器以 Java Servlet Filter 为基础，后者代表拦截请求和响应的对象。Filter 是 Java Servlet API 的一部分，在 Web 应用中扮演着重要角色，因为它们位于客户端和服务器处理逻辑之间。 利用它们，我们可以在请求到达 servlet 之前或生成响应之后执行任务。过滤器的常见用例包括 认证和授权 审计和日志 修改请求/响应 过滤器虽然不是 Spring 框架的一部分，但与 Spring 框架完全兼容。我们可以将它们注册为 Spring Bean，并在应用中使用它们。Spring 提供了一些过滤器的实现，其中常见的包括 OncePerRequestFilter 和 CorsFilter。 3、理解 chain.doFilter() 方法 在了解 chain.doFilter() 方法之前，首先要了解过滤器链（Filter Chain）的概念及其在过滤过程中的作用。 过滤器链表示应用于传入请求或传出响应的处理逻辑顺序流。换句话说，它是用于预处理请求或后处理响应的过滤器集合。这些过滤器以明确定义的顺序排列，确保每个过滤器都能在将请求或响应传递到链中的下一阶段之前执行其处理逻辑。 要定义过滤器链，可以使用了 Java Servlet API 中的 FilterChain 接口，其中包含了我们感兴趣的方法。查看该方法的签名，就会发现请求（request）和响应（response）对象被定义为输入参数： void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException; chain.doFilter() 方法将请求和响应传递给链中的下一个过滤器。如果过滤器链中没有过滤器，则会将请求转发给目标资源（通常是 Servlet），并将响应发送给客户端。 3.1、为什么调用 chain.doFilter() 非常重要？ 我们可以看到，chain. https://springdoc.cn/spring-data-jpa-query-arbitrary-and-clauses/ Tue, 17 Dec 2024 09:35:54 +0800 https://springdoc.cn/spring-data-jpa-query-arbitrary-and-clauses/ 1、概览 在使用 Spring Data 开发应用时，我们经常需要根据选择条件构建动态查询，以便从数据库中获取数据。 本文将带你了解在 Spring Data JPA Repository 中创建动态查询的三种方法：Example 查询、Specification 查询和 Querydsl 查询。 2、示例 创建 School 和 Student 两个实体。这两个实体类之间的关系是一对多，即一个 School 可以有多个 Student： @Entity @Table public class School { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column private Long id; @Column private String name; @Column private String borough; @OneToMany(mappedBy = "school") private List<Student> studentList; // 构造函数、Getter、Setter 省略 } @Entity @Table public class Student { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column private Long id; @Column private String name; @Column private Integer age; @ManyToOne private School school; // 构造函数、Getter、Setter 省略 } 除了实体类，还要为 Student 实体定义一个 Spring Data Repository： https://springdoc.cn/spring-ai-mcp-announcement/ Thu, 12 Dec 2024 09:35:27 +0800 https://springdoc.cn/spring-ai-mcp-announcement/ 我们很高兴推出 Spring AI MCP，它是模型上下文协议（Model Context Protocol，MCP）的强大 Java SDK 实现。Spring AI 生态系统的这一新成员为 Java 平台带来了标准化的 AI 模型集成能力。 MCP 是什么？ 模型上下文协议（MCP）是一种开放式协议，它规范了应用程序为大型语言模型（LLM）提供上下文的方式。MCP 提供了一种将人工智能模型连接到不同数据源和工具的标准化方法，使集成无缝且一致。它可以帮助你在 LLM 的基础上构建代理和复杂的工作流程。LLM 经常需要与数据和工具集成，而 MCP 提供了以下功能： 一个不断扩充的预构建集成列表，你的大语言模型（LLM）可以直接接入使用。 在不同的大语言模型（LLM）提供商和供应商之间灵活切换的能力。 总体结构 MCP 的核心是客户端-服务器（CS）架构，一个应用可以连接多个服务器。 Spring AI MCP 采用模块化架构，包含以下组件： Spring AI 应用： 使用 Spring AI 框架构建希望通过 MCP 访问数据的生成式 AI 应用。 Spring MCP 客户端：与服务器保持 1:1 连接的 MCP 协议的 Spring AI 实现。 MCP 服务器：轻量级程序，每个程序都通过标准化的模型上下文协议公开特定功能。 本地数据源：MCP 服务器可安全访问的计算机文件、数据库和服务。 远程服务：MCP 服务器可通过互联网（如 API）连接的外部系统。 该架构支持广泛的用例，从简单的文件系统访问到复杂的多模型人工智能与数据库和互联网连接的交互。 入门 Spring AI MCP GitHub：https://github.com/spring-projects-experimental/spring-ai-mcp Maven 依赖 在 Maven 项目中添加以下依赖之一 https://springdoc.cn/java-transform-future-completablefuture/ Mon, 09 Dec 2024 09:37:25 +0800 https://springdoc.cn/java-transform-future-completablefuture/ 1、简介 本文将带你了解如何将 Future 转换为 CompletableFuture。通过这种转换，我们可以利用 CompletableFuture 的高级功能，如非阻塞操作、链式任务和更好的错误处理，同时仍可使用返回 Future 的 API 或库。 2、为什么要把 Future 转换为 CompletableFuture? Java 中的 Future 接口表示异步计算的结果。它提供了检查计算是否完成、等待计算完成和检索结果的方法。 不过，Future 也有其局限性，比如阻塞调用需要使用 get() 来获取结果。此外，它还不支持链式调用多个异步任务或处理回调。 而，Java 8 中引入的 CompletableFuture 解决了这些缺陷。它通过用于任务链和回调的 thenApply() 和 thenAccept() 等方法支持非阻塞操作，并使用 exceptionally() 进行错误处理。 通过将 Future 转换为 CompletableFuture，我们可以在使用返回 Future 的 API 或库时利用这些功能。 3、逐步转换 来看看如何将 Future 转换为 CompletableFuture。 3.1、使用 ExecutorService 模拟 Future 要了解 Future 如何工作，我们首先要使用 ExecutorService 模拟异步计算。ExecutorService 是一个用于管理和调度独立线程中任务的框架。这将有助于我们理解 Future 的阻塞特性： @Test void givenFuture_whenGet_thenBlockingCall() throws ExecutionException, InterruptedException { ExecutorService executor = Executors.newSingleThreadExecutor(); Future<String> future = executor. https://springdoc.cn/jvm-advanced-options/ Sun, 08 Dec 2024 11:27:37 +0800 https://springdoc.cn/jvm-advanced-options/ 1、概览 Java 虚拟机（JVM）是驱动 Java 应用程序的强大引擎。它具有高度可定制性，通过标准选项提供基本配置，通过非标准选项进行一般性性能调优，以及通过高级选项实现精确控制。 高级选项允许开发人员对性能进行微调，诊断问题，并尝试最前沿的功能。 本文将带你了解最著名的高级 JVM 选项以及如何使用它们，从而对 JVM 行为进行更精细的控制。 2、JVM 选项的分类 JVM 参数可分为三大类： 标准选项（-version、-help） 非标准选项（-X: options） 高级选项（-XX: options） 3、理解高级 JVM 选项 高级选项不仅限于基本配置，还可以设置 JVM 的更低级属性。这些选项允许我们调整性能关键参数，如垃圾回收、内存管理和运行时诊断。 其中一些高级选项也是常用的最重要的 JVM 参数。不过，由于它们可以针对特定应用场景进行微调，我们必须谨慎使用。在不清楚应用程序行为的情况下过度定制，可能会导致性能低下、崩溃或意外行为。 此外，高级 JVM 选项并不能保证为所有 JVM 实现所支持，而且可能会发生变化。因此，由于这些选项会随着 JVM 的更新而变化，有些选项可能会过时，或者在较新版本中表现不同。 例如，Java 并发标记和清理垃圾收集（CMS）算法就曾出现过这种情况，该算法在 Java 9 中被弃用，并在 Java 14 中被删除。通过关注官方文档，我们可以在发生任何变化之前及时了解情况。 4、垃圾收集调整 垃圾回收对内存管理至关重要，但也会带来影响性能的停顿。高级选项可控制垃圾回收行为，确保应用程序运行更流畅。 从 Java 9 开始，默认情况下使用垃圾优先的垃圾收集器（G1），旨在平衡吞吐量和延迟。 为了克服 G1 的延迟限制，JDK12 引入了 Shenandoah GC，可以使用 -XX:+UseShenandoahGC 选项启用它。Shenandoah 的可用性取决于 JDK 供应商和版本。 还可以根据专门的工作负载使用其他实现方式。Epsilon 垃圾收集器也非常适合用于性能调优，以检查垃圾收集是否会影响我们程序的性能。 5、内存管理 如上所述，垃圾回收是内存管理的重要组成部分，但它只是 JVM 中更大的内存管理生态系统的一部分。 要实现最佳性能，同样重要的是配置内存分配、管理堆大小以及了解堆外内存的工作原理，特别是对于内存密集型应用或有特定性能要求的系统。 回顾一下与内存管理相关的一些高级 JVM 选项： https://springdoc.cn/java-postgresql-store-date-time/ Tue, 03 Dec 2024 09:52:23 +0800 https://springdoc.cn/java-postgresql-store-date-time/ 1、简介 在数据库中存储日期（Date）和时间（Time）信息是软件开发中的一项常见任务。由于有许多不同的格式、时区和存储格式，处理日期和时间可能是一项复杂的任务，如果处理不慎，可能会导致许多问题。 本文将带你了解 Java Date / Time API 提供的日期和时间类，以及 PostgreSQL 如何持久化这些类。 2、设置 本文使用 Spring Boot 和 Spring Data JPA 在 PostgreSQL 数据库中持久化日期和时间值。 首先，创建一个实体，其中包含 Java Date / Time API 中不同日期和时间类的字段： @Entity public class DateTimeValues { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Integer id; private Date date; private LocalDate localDate; private LocalDateTime localDateTime; private Instant instant; private ZonedDateTime zonedDateTime; private LocalTime localTime; private OffsetDateTime offsetDateTime; private java.sql.Date sqlDate; // Getter / Setter 省略 } 此外，还要添加一个默认构造函数，以固定时间初始化所有日期/时间字段： https://springdoc.cn/java-fix-the-jsonmappingexception-can-not-deserialize-instance-of-java-util-hashmap-out-of-start_array-token/ Tue, 03 Dec 2024 09:36:15 +0800 https://springdoc.cn/java-fix-the-jsonmappingexception-can-not-deserialize-instance-of-java-util-hashmap-out-of-start_array-token/ 1、概览 本文将带你了解如何解决 Jackson 异常：JsonMappingException: Can not deserialize instance of java.util.HashMap out of START_ARRAY token。 2、理解异常 简而言之，Jackson 在反序列化 JSON 字符串时抛出 JsonMappingException 来指示映射错误。而，“Can not deserialize instance of java.util.HashMap out of START_ARRAY token” 异常消息表示预期的数据结构与实际的 JSON 字符串不匹配。 这里出现不匹配是因为 Jackson 期望的是 List 而不是 HashMap。反序列化过程不知道如何将指定的 JSON 数组转换为 HashMap。因此出现异常。 3、示例 来看一个会导致 Jackson 出现 JsonMappingException 异常的例子。 为了简单起见，假设我们有一个 JSON 数组，其中每个元素都代表一个由名（firstName）和姓（lastName）定义的人： [ { "firstName":"Abderrahim", "lastName":"Azhrioun" }, { "firstName":"Nicole", "lastName":"Smith" } ] 现在，如果尝试将 JSON 数组直接反序列化为 Map，将导致 JsonMappingException： @Test public void givenJsonArray_whenDeserializingToMap_thenThrowException() { final String json = "[{\"firstName\":\"Abderrahim\",\"lastName\":\"Azhrioun\"}, {\"firstName\":\"Nicole\",\"lastName\":\"Smith\"}]"; final ObjectMapper mapper = new ObjectMapper(); Exception exception = assertThrows(JsonMappingException. https://springdoc.cn/http3-in-reactor-2024/ Fri, 29 Nov 2024 09:35:15 +0800 https://springdoc.cn/http3-in-reactor-2024/ HTTP/3 是 Hypertext Transfer Protocol（超文本传输协议，即 HTTP）的最新主要版本，其规范已于 2022 年 6 月定稿。该版本旨在提高性能、可靠性和安全性。与之前的版本不同，HTTP/3 使用 QUIC 而不是 TCP 作为传输层。QUIC 是一种基于 UDP 的多路复用安全传输协议，内置 TLS 1.3 加密，默认情况下 QUIC 是加密的。 要进一步了解 HTTP/3 的性能和优势，可以查看 《什么是 HTTP/3》。 有关浏览器采用情况的信息，请参阅《检查 HTTP/3 使用情况》，其中还提供了不同浏览器使用的 HTTP 版本的原始数据。 Reactor Netty 1.2（Reactor 2024.0 发布系列的一部分）添加了对 HTTP/3 的实验性支持。通过这个新版本的 Reactor Netty，你可以配置你的 Spring Boot 应用和 Spring Cloud Gateway 来支持 HTTP/3。 下面让我们看看如何配置 HTTP/3 支持。 配置 Reactor BOM Version Spring Boot 3.4 默认集成了 Reactor 2024.0 发布系列！ 如果你运行的是旧版本的 Spring Boot，你可以将 Reactor BOM 升级到 2024. https://springdoc.cn/spring-boot-3-4-release-notes/ Fri, 22 Nov 2024 09:33:05 +0800 https://springdoc.cn/spring-boot-3-4-release-notes/ 从 Spring Boot 3.3 升级 RestClient 和 RestTemplate 已添加对自动配置 RestClient 和 RestTemplate 以使用 Reactor Netty 的 HttpClient 或 JDK 的 HttpClient 的支持。按优先顺序，现在支持的客户端如下： Apache HTTP Components（HttpComponentsClientHttpRequestFactory） Jetty Client （JettyClientHttpRequestFactory） Reactor Netty HttpClient （ReactorClientHttpRequestFactory） JDK HttpClient （JdkClientHttpRequestFactory） Simple JDK HttpURLConnection （SimpleClientHttpRequestFactory） 需要注意的是，如果类路径上没有 HTTP Client 库，就可能会使用 JdkClientHttpRequestFactory，而之前使用的是 SimpleClientHttpRequestFactory。可以通过设置 spring.http.client.factory 来选择特定的客户端。支持的值包括 http-components、jetty、reactor、jdk 和 simple。 默认情况下，所有五个客户端都会自动跟随重定向。要禁用此行为，可将 spring.http.client.redirects 设置为 dont-follow 。 Apache HTTP Components 和 Envoy Apache HTTP Components（组件）更改了 HttpClient 中有关 HTTP/1.1 TLS 升级的默认设置。大多数代理服务器都能顺利处理升级，但 Envoy 或 Istio 可能会遇到问题。 https://springdoc.cn/mongodb-field-level-encryption/ Tue, 19 Nov 2024 17:17:23 +0800 https://springdoc.cn/mongodb-field-level-encryption/ 1、简介 本文将带你了解如何使用 MongoDB 的客户端字段级加密（或 CSFLE）来加密文档中的指定字段，主要介绍显式/自动加密和显式/自动解密，以及加密算法之间的差异。 2、场景与设置 MongoDB Atlas 和 MongoDB Enterprise 都支持自动加密。MongoDB Atlas 有一个 永久免费的集群，我们可以用它来测试所有功能。 此外，需要注意的是，字段级加密有别于静态存储，后者会对整个数据库或磁盘进行加密。通过有选择地加密特定字段，我们可以更好地保护敏感数据，同时实现高效查询和索引。 本文将从一个简单的 Spring Boot 应用开始，使用 Spring Data MongoDB 插入和检索数据。 首先，我们要创建一个包含未加密字段和加密字段混合的文档类。我们将从手动加密开始，然后看看如何通过 自动加密 实现同样的效果。对于手动加密，我们需要一个中间对象来表示加密的 POJO，并创建方法来加密/解密每个字段。 2.1. Spring Boot Starter 和加解密模块 首先，需要使用 spring-boot-starter-data-mongodb 来连接到 MongoDB： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> 然后，还需要 mongodb-crypt，以启用加密功能： <dependency> <groupId>org.mongodb</groupId> <artifactId>mongodb-crypt</artifactId> <version>1.7.3</version> </dependency> 由于我们使用的是 Spring Boot，所以只需上面两个依赖就足够了。 2.2、创建 Master Key Master Key（主密钥）用于加密和解密数据。任何拥有它的人都可以读取我们的数据。因此，确保主密钥的安全至关重要。 MongoDB 建议使用 远程密钥管理服务。不过，为了简单起见，本文使用本地密钥管理器，如下： public class LocalKmsUtils { public static byte[] createMasterKey(String path) { byte[] masterKey = new byte[96]; new SecureRandom(). https://springdoc.cn/spring-ai-advisors-guide/ Tue, 19 Nov 2024 09:37:32 +0800 https://springdoc.cn/spring-ai-advisors-guide/ 1、概览 AI 驱动的应用已成为我们的新现实。我们正在广泛实现各种 RAG 应用和提示 API，并使用 LLM 创建令人印象深刻的项目。借助 Spring AI，我们可以更快、更稳定地完成这些任务。 本文将带你了解 Spring AI Advisor 这一功能，它可以为我们处理各种常规任务。 2、Spring AI Advisor 是什么？ Advisors 是在 AI 应用程序中处理请求和响应的拦截器。我们可以使用它们为提示流程设置额外的功能。例如，可以建立聊天历史、排除敏感词或为每个请求添加额外的上下文。 该功能的核心组件是 CallAroundAdvisor 接口。我们通过实现该接口来创建 Advisor 链，从而影响我们的请求或响应。Advisor 流程如下图所示： 我们会将提示（prompt）发送到一个聊天模型，该模型关联了一个 Advisor 链。在发送提示之前，链上的每个 Advisor 都会执行其 before 操作。同样，在收到聊天模型的回复之前，每个 Advisor 都会调用自己的 after 操作。 3、ChatMemoryAdvisor ChatMemoryAdvisor 是一组非常有用的 Advisor 实现。我们可以使用这些 Advisor 提供与聊天提示的交流历史，从而提高聊天回复的准确性。 3.1、MessageChatMemoryAdvisor 使用 MessageChatMemoryAdvisor，我们可以通过 messages 属性提供聊天客户端调用的聊天历史记录。我们可以将所有消息保存在 ChatMemory 实现中，并控制历史记录的大小。 示例如下： @SpringBootTest(classes = ChatModel.class) @EnableAutoConfiguration @ExtendWith(SpringExtension.class) public class SpringAILiveTest { @Autowired @Qualifier("openAiChatModel") ChatModel chatModel; ChatClient chatClient; @BeforeEach void setup() { chatClient = ChatClient. https://springdoc.cn/java-fix-illegalstateexception-blocking/ Mon, 18 Nov 2024 11:27:49 +0800 https://springdoc.cn/java-fix-illegalstateexception-blocking/ 1、简介 Spring Webflux 是一个非阻塞的 Web 框架，从底层开始构建，旨在利用多核、下一代处理器的优势，处理大量并发连接（既然是非阻塞框架，线程就不应该被阻塞）。 本文将带你了解在使用 Spring Webflux 时常犯的一个错误。 2、Spring Webflux 线程模型 为了更好地理解这个问题，我们需要了解 Spring Webflux 的线程模型。 在 Spring Webflux 中，一个小型工作线程池负责处理传入请求。这与 Servlet 模型不同，在 Servlet 模型中，每个请求都有一个专用线程。因此，框架会保护（隔离）这些接受（处理）请求的线程。 理解了这一点后，继续往下看。 3、通过线程阻塞了解 IllegalStateException 让我们通过一个示例来了解 Spring Webflux 中何时以及为何会出现异常：“java.lang.IllegalStateException: block()/blockFirst()/blockLast() are blocking, which is not supported in thread”。 以文件搜索 API 为例。该应用从文件系统读取文件，并在文件中搜索用户提供的文本。 3.1、FileService 先定义一个 FileService 类，它能以字符串形式读取文件内容： @Service public class FileService { @Value("${files.base.dir:/tmp/bael-7724}") private String filesBaseDir; public Mono<String> getFileContentAsString(String fileName) { return DataBufferUtils.read(Paths.get(filesBaseDir + "/" + fileName), DefaultDataBufferFactory.sharedInstance, DefaultDataBufferFactory.DEFAULT_INITIAL_CAPACITY) . https://springdoc.cn/java-incompatibleclasschangeerror/ Mon, 18 Nov 2024 10:45:07 +0800 https://springdoc.cn/java-incompatibleclasschangeerror/ 1、概览 本文将带你了解 Java 中的 IncompatibleClassChangeError 异常，这是一种运行时异常，当 JVM 检测到类的更改与之前加载的类不兼容时就会发生。 本文将带你了解出现这个异常的原因以及解决办法。 2、IncompatibleClassChangeError 类 IncompatibleClassChangeError 是 Java 中的一种 LinkageError。该异常通常表示一个或多个依赖类出现了问题。 IncompatibleClassChangeError（不兼容类变更错误）是 LinkageError 的子类，当一个或多个从属类的类定义发生不兼容变更时会导致该异常。 注意，这是 Error 的子类，因此不应该试图 catch 这些异常，因为这意味着应用程序或运行时出现异常需要进行处理。 3、异常的产生 接下来，让我们模拟一种会导致 IncompatibleClassChangeError 的情况。 3.1、预定义一个第三方库 首先创建一个简单的库（项目），其中有一个父类 Dinosaur 和一个子类 Coelophysis，后者继承自 Dinosaur： public class Dinosaur { public void species(String sp) { if(sp == null) { System.out.println("I am a generic Dinosaur"); } else { System.out.println(sp); } } } public class Coelophysis extends Dinosaur { public void mySpecies() { species("My species is Coelophysis of the Triassic Period"); } public static void main(String[] args) { Coelophysis coelophysis = new Coelophysis(); coelophysis. https://springdoc.cn/using-date-time-classes-in-java/ Mon, 11 Nov 2024 13:31:25 +0800 https://springdoc.cn/using-date-time-classes-in-java/ 在开发时候，发现有很多需要用到时间的地方，例如记录操作的时间、比较时间判断产品是否有效等。总而言之，时间是我们业务开发必须关注、时刻注意的点。但目前工程的代码中使用了非常多时间的工具类，一会儿用 java.util.Date 记录时间，一会用 java.time.LocalDateTime 记录时间，怎么才能在 Java 中优雅的操纵时间呢，我整理了相关的概念和工具类，希望帮助大家在代码开发的过程中对对时间的使用更加优雅。 这里先写一个结论： 建议使用 java8 的时间 API，在安全性和易用性上都远高于 java.util.Date。 目前比较流行的封装 java API 的时间工具类大都基于 java.util.Date，建议在开发过程中根据业务需要基于 java.time.* 的方法封装工具类（文末给出了一个简单的实现）。 时间在计算机中的存储和展示 时间以整数的方式进行存储：时间在计算机中存储的本质是一个整数，称为 Epoch Time（时间戳），计算从 1970 年 1 月 1 日零点（格林威治时间/GMT+00:00）到现在所经历的秒数。 在 java 程序中，时间戳通常使用 long 表示毫秒数，通过 System.currentTimeMillis() 可以获取时间戳。时间戳对我们人来说是不易理解的，因此需要将其转换为易读的时间，例如，2024-10-7 20:21:59（实际上说的是本地时间），而同一时刻不同时区的人看到的本地时间是不一样，所以在时间展示的时候需要加上时区的信息，才能精准的找到对应的时刻。 时区与世界时间标准相关： 世界时间的标准在 1972 年发生了变化，但我们在开发程序的时候可以忽略 GMT 和 UTC 的差异， 因为计算机的时钟在联网的时候会自动与时间服务器同步时间。 本地时间等于我们所在（或者所使用）时区内的当地时间，它由与世界标准时间（UTC）之间的偏移量来定义。这个偏移量可以表示为 UTC- 或 UTC+，后面接上偏移的小时和分钟数。 例如：GMT+08:00 或者 UTC+08:00 表示东八区，2024-10-7 20:21:59 UTC+08:00 便可以精准的定位一个时刻。 日期 API JDK 以版本 8 为界，有两套处理日期/时间的 API。 简单的比较如下： 特性 java.util.Date java.util.Date.Calendar java.time.LocalDateTime 线程安全 ❌ ❌ ✅ 时间运算 ❌ ✅ ✅ 可读性 Tue Oct 08 00:11:16 CST 2024 易读性较低 ❌不易读 ✅ yyyy-MM-dd’T’HH:mm:ss 常量设计 需要对获取的年份（+1900）月份（0-11）进行处理 需要对获月份（0-11）进行处理 ✅ 不需要额外处理，符合常识 时间精度 精确到毫秒 精确到毫秒 精确到纳秒 时区 具体的时间调用 不 - 特性 java. https://springdoc.cn/java-entitymanagerfactory-vs-sessionfactory/ Mon, 11 Nov 2024 10:21:01 +0800 https://springdoc.cn/java-entitymanagerfactory-vs-sessionfactory/ 1、简介 本文将带你了解 SessionFactory 和 EntityManagerFactory 之间的异同。 顾名思义，这两个类都是用于创建数据库通信对象的工厂类。除了创建对象，它们还提供了其他功能，帮助我们与数据库进行交互。 2、EntityManagerFactory 是什么？ Java 持久化 API（JPA）是 Java 应用管理持久化数据的规范。它提供了一种与关系数据库交互的标准方式。EntityManager（实体管理器）作为 JPA 的核心接口，用于与持久化上下文交互并管理实体的生命周期。它为基本的 CRUD 操作提供了具有方法的轻量级实例。 EntityManagerFactory 是一个 JPA 接口，用于创建 EntityManager 实例，以线程安全的方式与持久化上下文（Persistence Context）交互。 2.1、示例 首先，先定义实体： @Entity(name = "persons") public class Person { @Id @GeneratedValue(strategy= GenerationType.IDENTITY) private Integer id; private String name; private String email; // Getter / Setter 省略 } 设置配置有多种方法，这里使用 persistence.xml 配置文件的方法。首先，需要在 resource/META-INF 文件夹中创建该配置文件，并定义连接配置： <persistence-unit name="com.baeldung.sfvsemf.persistence_unit" transaction-type="RESOURCE_LOCAL"> <description>Persistence Unit for SessionFactory vs EntityManagerFactory code example</description> <class>com.baeldung.sfvsemf.entity.Person</class> <exclude-unlisted-classes>true</exclude-unlisted-classes> <properties> <property name="hibernate. https://springdoc.cn/java-jdbc-oracle-connection/ Mon, 11 Nov 2024 09:46:32 +0800 https://springdoc.cn/java-jdbc-oracle-connection/ 1、概览 Oracle 数据库是最流行的关系数据库之一。本文将带你了解如何使用 JDBC 驱动连接到 Oracle 数据库。 2、数据库 首先，我们需要一个数据库。如果没有，则可以从 Oracle Database Software Downloads 下载并安装免费版本，或者使用 Oracle Database Container Images 上的 Docker 镜像。 本文中使用的是 Oracle Database 23ai (23.5.0) 的 Docker 镜像。 3、Maven 依赖 数据库就绪后，在项目中添加 Oracle 的 JDBC 驱动依赖，本文使用 ojdbc11 连接 Oracle 23ai： <dependency> <groupId>com.oracle.database.jdbc</groupId> <artifactId>ojdbc11</artifactId> <version>23.5.0.24.07</version> </dependency> ojdbc11 的最新版本可在 Central Maven Repository 中找到。该依赖项要求 Java 11 或更高版本，是较新版本 Java 的推荐驱动。 为了向后兼容，ojdbc8 可用于 Java 8。也推荐使用 ojdbc10 作为 Oracle 19c 的驱动程序。 4、连接到数据库 首先，创建一个 OracleDataSource（Oracle 数据源接口的实现）。这比使用 DriverManager 更好，因为 DataSource 更具可扩展性，也更易于设置。 https://springdoc.cn/spring-jpa-troubleshooting-attribute-naming-issues/ Fri, 08 Nov 2024 10:28:59 +0800 https://springdoc.cn/spring-jpa-troubleshooting-attribute-naming-issues/ 1、简介 Spring 为程序员简化 Java 应用程序中的数据库交互提供了一个最强大的框架，那就是 Spring JPA（Java Persistence API）。它为 JPA 提供了一个稳定的抽象。 然而，尽管使用方便，开发人员还是经常会遇到一些错误，而这些错误的排查和解决都非常具有迷惑性。其中一个常见问题就是 “Unable to Locate Attribute with the Given Name” 错误。 本文将带你了解 Spring JPA 出现 “Unable to Locate Attribute with the Given Name” 异常的原因以及解决办法。 2、案例 我们生产了一个可穿戴的小工具。经过最近的一项调查，我们的营销团队发现，在我们的平台上按传感器类型、价格和受欢迎程度对产品进行分类，可以突出最受欢迎的产品，从而帮助客户做出更好的购买决策。 3、添加 Maven 依赖 我们使用 H2 内存数据库在项目中创建一个可穿戴设备表，并将样本数据填充到该表中，以便在接下来的测试中使用。 首先，添加以下 Maven 依赖： <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.2.224</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <version>2.7.11</version> </dependency> 4、应用配置 在 src/main/resources 文件夹中，创建包含以下配置内容的 application-h2.properties： # H2 配置 hibernate.dialect=org.hibernate.dialect.H2Dialect hibernate.hbm2ddl.auto=create-drop # Spring Datasource URL spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1 在 src/main/resources 文件夹中创建名为 testdata. https://springdoc.cn/spring-data-find-by-property-nested-object/ Fri, 08 Nov 2024 10:08:48 +0800 https://springdoc.cn/spring-data-find-by-property-nested-object/ 1、概览 在 Spring Data 中，使用基于方法名称的派生查询来查询实体是很常见的。在处理实体之间的关系（如嵌套对象）时，Spring Data 提供了各种机制来检索这些嵌套对象中的数据。 本文将带你了解如何使用查询派生和 JPQL（Java 持久性查询语言）通过嵌套对象的属性进行查询。 2、场景概述 考虑一个有两个实体的简单场景：Customer 和 Order。每个 Order 都通过 ManyToOne（多对一）关系关联到一个 Customer。 我们要查找属于某个 Customer 的所有 Order，该 Customer 有特定的 email。在这种情况下，email 是 Customer 实体的属性，而我们的主要查询将在 Order 实体上执行。 实体示例如下： @Entity @Table(name = "customers") public class Customer { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private String email; // Getter / Setter 省略 } @Entity @Table(name = "orders") public class Order { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private Date orderDate; @ManyToOne @JoinColumn(name = "customer_id") private Customer customer; // Getter / Setter 省略 } 3、使用派生查询 Spring Data JPA 允许开发者从 Repository 接口中的方法签名派生查询，从而简化了查询创建： https://springdoc.cn/java-scheduledexecutorservice-virtual-threads/ Thu, 07 Nov 2024 11:21:36 +0800 https://springdoc.cn/java-scheduledexecutorservice-virtual-threads/ 1、简介 虚拟线程是 JDK 21 中正式引入的一项杀手锏级别的功能，是提高应用程序性能、吞吐量的一种解决方案。 但是，JDK 没有内置的使用虚拟线程的任务调度器。因此，我们得自己编写使用虚拟线程运行的任务调度器。 本文将带你了解如何使用 Thread.sleep() 方法和 ScheduledExecutorService 类为虚拟线程创建自定义调度器。 2、虚拟线程是什么？ JEP-444 中引入了虚拟线程，作为线程类的轻量级版本，提高了应用程序的并发性和吞吐量。 虚拟线程占用的空间比通常的操作系统线程（或平台线程）要少得多。因此，我们可以在应用程序中同时产生比平台线程更多的虚拟线程。毫无疑问，这增加了并发单元的最大数量，也提高了应用程序的吞吐量。 关键的一点是，虚拟线程并不比平台线程更快（任务的耗时不会有改变）。在我们的应用中，虚拟线程的数量只比平台线程多，这样它们就能执行更多的并行工作。 虚拟线程的成本很低，因此我们不需要使用资源池等技术来为数量有限的线程安排任务。相反，我们可以在现代计算机中几乎无限地生成虚拟线程，而不会出现内存问题。 最后，虚拟线程是动态的，而平台线程的大小是固定的。因此，虚拟线程比平台线程更适合小型任务，如简单的 HTTP 或数据库调用。 3、虚拟线程调度 如上所述，虚拟线程的一大优势是体积小、成本低。我们可以在一个简单的机器中有效地生成数百万个虚拟线程，而不会出现内存不足的错误。因此，像使用平台线程、网络或数据库连接等更昂贵的资源那样池化虚拟线程并没有太大意义。 如果使用线程池，就会产生另一种开销，即为池中可用的线程调度任务，这将更加复杂，速度也可能更慢。此外，Java 中的大多数线程池都受到平台线程数的限制，而平台线程数总是小于程序中可能存在的虚拟线程数。 因此，我们必须避免使用带有线程池 API（如 ForkJoinPool 或 ThreadPoolExecutor）的虚拟线程。相反，我们应该始终为每个任务创建一个新的虚拟线程。 目前，Java 并没有提供使用虚拟线程进行调度的标准 API，就像我们使用其他并发 API（如 ScheduledExecutorService 的 schedule() 方法）一样。因此，为了有效地让虚拟线程运行计划任务，我们需要编写自己的 Scheduler（调度器）。 3.1、使用 Thread.sleep() 调度虚拟线程 创建自定义 Scheduler 的最直接方法是使用 Thread.sleep() 方法，让程序在当前线程执行时等待： static Future<?> schedule(Runnable task, int delay, TemporalUnit unit, ExecutorService executorService) { return executorService.submit(() -> { try { Thread.sleep(Duration.of(delay, unit)); } catch (InterruptedException e) { Thread. https://springdoc.cn/java-date-time-history/ Thu, 07 Nov 2024 10:01:05 +0800 https://springdoc.cn/java-date-time-history/ 1、概览 处理 Date（日期）和 Time（时间）是许多 Java 应用程序的基本组成部分。多年来，Java 在处理日期方面不断发展，引入了更好的解决方案来简化开发者的工作。 2、传统的日期和时间处理类 在 java.time 包出现之前，Java 主要使用 Date 和 Calendar 类来处理日期。尽管它们现在也可以使用，但是有一些缺陷。 2.1、java.util.Date 类 java.util.Date 类是 Java 最初处理日期的解决方案，但它有一些缺点： 它是可变的，这意味着可能会遇到 线程安全 问题。 不支持时区。 它使用了令人困惑的方法名称和返回值，比如 getYear()，它返回的是自 1900 年以来的年数。 许多方法已废弃。 使用无参数构造函数创建 Date 对象，表示当前日期和时间（对象创建时）。 如下，实例化一个 Date 对象并打印其值： Date now = new Date(); logger.info("Current date and time: {}", now); 这将输出当前日期和时间，如 Wed Sep 24 10:30:45 PDT 2024。虽然该构造函数仍然有效，但由于上述原因，这里不再建议新项目使用该构造函数。 2.2、java.util.Calendar 类 由于 Date 的局限性，Java 引入了 Calendar 类，对其进行了改进： 支持各种日历系统。 时区管理。 更加直观的日期操作方法。 我们可以使用 Calendar 操作日期。 Calendar cal = Calendar. https://springdoc.cn/jakarta-persistence-3-2/ Wed, 06 Nov 2024 11:03:27 +0800 https://springdoc.cn/jakarta-persistence-3-2/ 1、简介 Jakarta Persistence（前身为 JPA）是 Java 中对象关系映射的标准 API。它使开发人员能够在 Java 应用中管理关系数据，并通过使用注解和实体类将 Java 对象映射到数据库表来简化数据库交互。 本文将带你了解 Jakarta Persistence 3.2 中引入的一些关键新功能，重点介绍在配置、性能和可用性方面的改进。 2、Jakarta Persistence 3.2 是什么？ Jakarta Persistence 3.2 是 Jakarta Persistence API 的最新版本，它为 Java 应用中的对象关系映射（ORM）提供了一种标准化方法。 该版本改进了查询功能、性能和可用性，并增强了对现代数据库功能的支持。 要添加对 Jakarta Persistence 3.2 的支持，必须在 pom.xml 中添加以下 Maven 依赖： <dependency> <groupId>jakarta.persistence</groupId> <artifactId>jakarta.persistence-api</artifactId> <version>3.2.0</version> </dependency> 此外，还需要支持该 API 的最新 Hibernate 7 版本： <dependency> <groupId>org.hibernate.orm</groupId> <artifactId>hibernate-core</artifactId> <version>7.0.0.Beta1</version> </dependency> 3、关键的新功能 Jakarta Persistence 3.2 引入了一些新功能，以改进数据库连接处理、模式配置和事务管理。 3.1、持久化配置 最新的 Jakarta Persistence 3.2 版本添加了编程式 API，可使用 PersistenceConfiguration 类而不是传统的 persistence. https://springdoc.cn/java-openapi2-openapi3-upgrade/ Wed, 06 Nov 2024 10:17:39 +0800 https://springdoc.cn/java-openapi2-openapi3-upgrade/ 1、简介 尽管 OpenAPI 3.x 规范自 2017 年起就已发布，并经历了多次更新，但目前许多 API 仍在继续使用旧版本。 本文将带你了解 OpenAPI 2.0 和 OpenAPI 3.0 规范之间的主要区别，以及如何将 OpenAPI 2.0 规范转换为 OpenAPI 3.0。 2、OpenAPI 2.0 和 OpenAPI 3.0 简单回顾一下，OpenAPI 提供了一种标准格式，用于描述人类和机器都能读懂的 HTTP API。在 3.0 版之前，OpenAPI 被称为 Swagger 规范和 Swagger 工具包的一部分。从那时起，它已成为行业标准，并经过多次更新，带来了更多改进和功能。 与 2.0 相比，OpenAPI 3.0 引入了几项根本性变化。 首先，对整体结构进行了重构，以提高可重用性。添加了一个 components（组件）块来组织现有元素（如 schemas、responses、parameters）和新元素（请求 requestBody、examples 和 headers）。一些元素被重新命名 - definitions 现在被称为 schemas，securityDefinitions 被称为 securitySchemes。 此外，OpenAPI 3.0 还进一步扩展了 JSON Schema 功能。添加了 oneOf、anyOf 和 not 等关键字，以便对复杂的数据格式进行描述和灵活验证。 3.0 版本还引入了对 cookie 参数、内容类型协商和回调机制的支持。它还扩展了安全定义并简化了现有流程。 最后，你可以在官方 更新日志 中查看完整的变更列表。 https://springdoc.cn/java-ssh-remote-mysql-db-connection/ Wed, 06 Nov 2024 09:37:04 +0800 https://springdoc.cn/java-ssh-remote-mysql-db-connection/ 1、概览 Secure Shell（SSH）允许我们安全地访问和管理远程系统，包括执行命令、传输文件和隧道服务。 我们可以通过 SSH 会话建立与远程 MySQL 数据库的连接。Java 有多个 SSH 客户端，其中最常见的是 Java Secure Channel（JSch）。 本文将带你了解如何通过 SSH 会话连接到运行在远程服务器上的 MySQL 数据库。 2、了解 SSH 端口转发 端口转发允许通过在 SSH 连接上将流量从本地端口重定向到远程服务器上的端口，从而实现客户系统和远程服务器之间的数据传输。 当防火墙或其他限制阻止直接连接远程服务器的 IP 和端口时，这一点尤其有用。 在本例中，MySQL 服务器运行在远程服务器的 localhost 上，通常使用 3306 端口。虽然从技术上讲，可以直接连接到远程服务器的 IP 和 MySQL 端口，但出于安全考虑，这通常会受到限制（3306 端口未开放）。相反，我们可以通过 SSH 使用本地端口转发来建立与数据库的安全连接。 在本地端口转发中，我们在本地机器上分配一个可用端口，并将其与远程运行的 MySQL 服务器端口绑定，以允许我们的程序与远程服务器之间进行数据通信。 3、Maven 依赖 首先，在 pom.xml 中添加 JSch 和 MySQL 驱动依赖： <dependency> <groupId>com.github.mwiede</groupId> <artifactId>jsch</artifactId> <version>0.2.20</version> </dependency> <dependency> <groupId>com.mysql</groupId> <artifactId>mysql-connector-j</artifactId> <version>9.0.0</version> </dependency> JSch 提供了 Session 等类，这些类对于建立与远程服务器的 SSH 连接至关重要。此外，MySQL 驱动允许我们与运行中的 MySQL 服务器建立连接。 https://springdoc.cn/java-mysqldatatruncation-data-truncation-data-too-long-for-column/ Tue, 05 Nov 2024 10:41:17 +0800 https://springdoc.cn/java-mysqldatatruncation-data-truncation-data-too-long-for-column/ 1、概览 Java 数据库连接（JDBC）应用编程接口（API）提供了一系列类和接口。我们可以使用它们连接关系数据库等数据源并运行 SQL 语句。 以流行的 MYSQL 为例，当我们需要连接到 MySQL 时，就需要使用 MySQL 数据库的专用 JDBC 驱动程序： com.mysql.cj.jdbc.Driver，该驱动实现了 JDBC API。 在运行 SQL 语句时，我们可能会遇到异常：“com.mysql.cj.jdbc.exceptions.MysqlDataTruncation: Data truncation: Data too long for column”。 本文将带你了解出现此异常的原因，以及解决办法。 2、Schema 设置 首先，创建如下关系表 department： DESC department; +-------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-------+-------------+------+-----+---------+-------+ | id | int | NO | PRI | NULL | | | name | varchar(50) | YES | | NULL | | | code | varchar(4) | YES | | NULL | | +-------+-------------+------+-----+---------+-------+ 注意，code 列定义只允许使用大小为 4 或更小的 varchar。 https://springdoc.cn/java-bouncy-castle-sign-csr/ Tue, 05 Nov 2024 09:42:10 +0800 https://springdoc.cn/java-bouncy-castle-sign-csr/ 1、概览 签署（也叫做签发）证书签名请求（CSR）是密码学中的一项常见操作。本文将带你了解如何使用 Bouncy Castle 签署 CSR。 2、签署 CSR 签署 CSR 是证书颁发机构（CA）验证 CSR 中的信息并颁发证书的过程。CA 使用其私钥签署证书。签名后的证书可在客户端和服务器之间建立安全连接。 要使用 Bouncy Castle 签署 CSR，需要执行几个基本步骤： 生成可信实体 CA 证书和私钥。 生成证书签名请求（CSR）。 使用 CA 证书和私钥签署 CSR。 3、设置 首先，需要在 pom.xml 中添加 Bouncy Castle 依赖： <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcpkix-jdk18on</artifactId> <version>1.76</version> </dependency> 接下来，需要创建一个 SecurityProvider 类来注册 Bouncy Castle Provider： static { Security.addProvider(new BouncyCastleProvider()); } 4、使用 Bouncy Castle 签署 CSR 使用 Bouncy Castle 签署 CSR 需要几个步骤。 4.1、生成可信实体 CA 证书和私钥 CA 是向客户签发证书的可信实体。我们必须生成 CA 证书和私钥来签署 CSR。 先生成一个密钥对： https://springdoc.cn/java-interface-vs-annotation/ Sat, 28 Sep 2024 10:57:06 +0800 https://springdoc.cn/java-interface-vs-annotation/ 1、概览 本文将带你了解 Java 中 interface（接口）和 @interface（注解接口）的区别以及它们的应用。 interface是一个类实现的规范。在最常见的形式中，它是一组相关方法，这些方法没有具体的实现。 而 @interface 则允许你在代码中添加元数据。编译器、工具或框架使用这些元数据来影响类的行为或处理过程。 2、interface interface 是一种规范。它规定了实现类必须实现的行为，但没有规定如何实现。它表明，任何实现接口的类都必须为接口的所有方法提供具体的实现。 public interface Animal { String eat(); String sleep(); } public class Dog implements Animal { @Override public String eat() { return "Dog is eating"; } @Override public String sleep() { return "Dog is sleeping"; } } 接口的所有方法都是默认 public 和 abstract 的（default 方法和 static 方法除外），所有字段都是 public、static 和 final 的。在 Java 中，我们可以使用接口实现抽象、多重继承和松散耦合。 抽象：接口只定义了调用方法所需的基本信息，而实现方法的复杂性则被隐藏起来。 多重继承：一个类可以实现多个接口，从而避免了在允许类多重继承的语言中可能出现的 “菱形继承” 问题。 松耦合：接口在功能和实现细节之间提供了明显的分离。由于我们对方法和签名进行了单独定义，它使一个类可以改变其内部流程，而不影响其用户。 3、@interface 在Java中，我们使用 @interface 来声明注解类型。注解提供了一种向 Java 代码元素（如类、方法和字段）添加元数据的方式。因此，工具和库可以利用这些元数据在编译过程或运行时收集信息，以进行代码处理。 https://springdoc.cn/kafka-instancealreadyexistsexception/ Thu, 26 Sep 2024 11:31:06 +0800 https://springdoc.cn/kafka-instancealreadyexistsexception/ 1、简介 Apache Kafka 是一个功能强大的分布式流平台，被广泛用于构建实时数据管道和流应用。然而，Kafka 在运行过程中可能会遇到各种异常和错误。其中一个常见的异常就是 InstanceAlreadyExistsException。 本文将带你了解 Kafka 出现 InstanceAlreadyExistsException 异常的原因和解决办法。 2、InstanceAlreadyExistsException 异常是什么？ InstanceAlreadyExistsException 是 java.lang.RuntimeException 的子类。在 Kafka 的上下文中，这个异常通常在尝试创建具有与现有生产者或消费者相同的 Client ID 的 Kafka 生产者或消费者时出现。 每个 Kafka 客户端实例都有一个唯一的 Client ID，它对 Kafka 集群内的元数据跟踪和客户端连接管理至关重要。如果试图创建一个新的客户端实例，而 Client ID 已被现有客户端使用，Kafka 会抛出 InstanceAlreadyExistsException（实例已存在异常）。 3、内部机制 虽然我们提到 Kafka 会抛出这个异常，但值得注意的是，Kafka 通常会在其内部机制中优雅地处理这个异常。通过在内部处理异常，Kafka 可以将问题隔离和限制在其自身的子系统中。这可以防止异常影响主线程，并潜在地导致更广泛的系统不稳定或停机。 在 Kafka 的内部实现中，registerAppInfo() 方法通常在初始化 Kafka 客户端（生产者或消费者）时被调用。假设现有的客户端有相同的 client.id，该方法会捕获 InstanceAlreadyExistsException。由于异常是在内部处理的，它不会被抛到主线程上，而人们可能希望在主线程上捕获异常。 4、InstanceAlreadyExistsException 的原因 在本节中，我们将通过代码示例来研究导致 InstanceAlreadyExistsException 的各种情况。 4.1、消费者组中重复的 Client ID Kafka 规定同一消费者组内的消费者有不同的 Client ID。当一个组内的多个消费者共享相同的 Client ID 时，Kafka 的消息传递语义可能会变得不可预测。这会干扰 Kafka 管理偏移量和维护消息顺序的能力，可能导致消息重复或丢失。因此，当多个消费者共享同一个 Client ID 时，就会触发该异常。 https://springdoc.cn/spring-ai-mongodb-rag/ Thu, 26 Sep 2024 10:05:59 +0800 https://springdoc.cn/spring-ai-mongodb-rag/ 1、概览 AI（人工智能）技术的使用正成为现代开发中的一项关键技能。在本文中，我们将构建一个 RAG Wiki 应用，它可以根据存储的文档回答问题。 我们会通过 Spring AI 将应用与 MongoDB Vector 数据库 和 LLM 集成。 2、RAG 应用 当自然语言生成需要依赖上下文数据时，我们就会使用 RAG（Retrieval-Augmented Generation）应用。RAG 应用的一个关键组成部分是向量数据库（Vector Database），它在有效管理和检索这些数据方面起着至关重要的作用： 我们使用 Embedding Model 来处理源文件。Embedding Model 将文档中的文本转换为高维向量。这些向量捕捉了内容的语义，使我们能够根据上下文而不仅仅是关键词匹配来比较和检索类似的内容。然后，我们将文档存储到向量数据库。 保存文档后，我们可以通过以下方式发送提示信息： 首先，我们使用 Embedding Model 来处理问题，将其转换为捕捉其语义的向量。 接下来，进行相似性搜索，将问题的向量与存储在向量库中的文档向量进行比较。 从最相关的文档中，为问题建立一个上下文。 最后，将问题及其上下文发送给 LLM，LLM 会根据所提供的上下文构建与查询相关的回复。 3、MongoDB Atlas Search 在本教程中，我们将使用 MongoDB Atlas Search 作为我们的向量数据库。它提供的向量搜索功能可以满足我们在本项目中的需求。为了测试，我们使用 mongodb-atlas-local Docker 容器来设置 MongoDB Atlas Search 的本地实例。 创建一个 docker-compose.yml 文件： version: '3.1' services: my-mongodb: image: mongodb/mongodb-atlas-local:7.0.9 container_name: my-mongodb environment: - MONGODB_INITDB_ROOT_USERNAME=wikiuser - MONGODB_INITDB_ROOT_PASSWORD=password ports: - 27017:27017 4、依赖和配置 首先，添加必要的依赖项。由于我们的应用要提供 HTTP API，因此加入 spring-boot-starter-web 依赖： https://springdoc.cn/spring-boot-3-3-4-available-now/ Tue, 24 Sep 2024 11:31:55 +0800 https://springdoc.cn/spring-boot-3-3-4-available-now/ Spring Boot v3.3.4 现已发布。 🐞 Bug 修复 当封装了 AbstractRoutingDataSource 时，management.health.db.ignore-routing-datasources=true 无效 #42322 OAuth2ClientProperties 验证错误信息中缺少详细信息 #42279 来自未使用的错误配置 SSL bundle 的 FileNotFoundException #42169 当 spring-web 不在 classpath 上时，ZipkinHttpClientSender 会出现 “Failed to introspect Class”（类自省失败）#42161 与容器 Bean 一起使用时，@RestartScope 可能会导致 “Recursive update（递归更新）”异常 #42107 JarLauncher 无法加载大型 jar 文件 #42079 PropertiesMigrationListener 错误地将具有 group 的属性报告为已废弃属性 #42071 在 MongoDB 中使用空字符串的 ‘replica-set-name’ 属性将导致 ClusterType=REPLICA_SET #42059 默认 Logback 配置使用过时的 “converterClass” 属性 #42006 📔 文档 关于 spring.jmx.enabled 不适用于第三方库的文件 #42285 更新指向 Log4j2 系统属性（system properties）的链接 #42263 参考指南中的 GraphQL 链接重定向到根目录，而不是特定部分 #42208 参考指南中 “被动接收信息部分（Receive a message reactively section）” 的语法错误 #42200 autotime 启用、percentiles 和 percentiles-historgram 属性被废弃的原因令人困惑。 #42193 在属性文件中用 RFC 9457 取代 RFC 7807 #42190 不支持将配置属性绑定到带有默认值的 Kotlin 值类的文档 #42176 更新文档以反映新的未找到 Handler 的异常行为 #42167 波兰语配置属性参考 #42165 移除指向 “将 Spring Boot JAR 应用转换为 WAR” 的链接，因为该指南已不再可用 #42111 修正 Metric 文档页面上的 StatsD 链接错字 #42109 改进无需构建包的 docker 文档 #42106 改进 “命令行自动补全”中的文档 #42103 测试部分缺少 Kotlin 代码示例 #42094 修复 Colima 的 Docker 配置中的错误命令 #42078 Gradle Plugin AOT 文档中有示例错误 #42046 🔨 依赖升级 升级依赖到 Groovy 4. https://springdoc.cn/feign-client-completablefuture-spring-boot/ Tue, 24 Sep 2024 10:40:11 +0800 https://springdoc.cn/feign-client-completablefuture-spring-boot/ 1、简介 在处理分布式系统时，调用外部服务并保持低延迟是一项至关重要的任务。 本文将带你了解如何使用 OpenFeign 和 CompletableFuture 来并行处理多个 HTTP 请求，处理错误，并设置网络和线程超时。 2、示例项目 为了说明并行请求的用法，我们要实现一个功能，允许客户在网站上购买物品。首先，该服务发出一个请求，根据客户所在国家获取可用的付款方式。其次，它发送一个请求给客户生成有关购买的报告。购买报告不包括有关付款方式的信息。 先添加 spring-cloud-starter-openfeign 依赖： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> 3、创建调用外部依赖的客户端 使用 @FeignClient 注解创建两个指向 localhost:8083 的客户端： @FeignClient(name = "paymentMethodClient", url = "http://localhost:8083") public interface PaymentMethodClient { @RequestMapping(method = RequestMethod.GET, value = "/payment_methods") String getAvailablePaymentMethods(@RequestParam(name = "site_id") String siteId); } 第一个客户端名为 paymentMethodClient。它调用 GET /payment_methods，使用代表客户所在国家/地区的 site_id 请求参数获取可用的付款方式。 第二个客户端如下： @FeignClient(name = "reportClient", url = "http://localhost:8083") public interface ReportClient { @RequestMapping(method = RequestMethod.POST, value = "/reports") void sendReport(@RequestBody String reportRequest); } 我们将其命名为 reportClient，它调用 POST /reports 生成购买报告。 https://springdoc.cn/stream-api-jdbc-resultset/ Tue, 24 Sep 2024 10:01:25 +0800 https://springdoc.cn/stream-api-jdbc-resultset/ 1、概览 通常，我们使用遍历从 JDBC ResultSet 中迭代检索到的数据，不过在某些情况下，我更喜欢用 record Stream。 本文将带你了解使用 Stream API 处理 JDBC 结果集的几种方法。 2、使用 Spliterators 首先是纯 JDK 方法，使用 Spliterators 创建流。 首先，为实体定义一个 Model： public record CityRecord(String city, String country) { } 在 CityRecord 中，我们存储了有关 city（城市）及其 country（国家）的信息。 接下来，创建一个能与数据库交互并返回 Stream<CityRecord> 的 Repository： public class JDBCStreamAPIRepository { private static final String QUERY = "SELECT name, country FROM cities"; private final Logger logger = LoggerFactory.getLogger(JDBCStreamAPIRepository.class); public Stream<CityRecord> getCitiesStreamUsingSpliterator(Connection connection) throws SQLException { PreparedStatement preparedStatement = connection. https://springdoc.cn/spring-security-firebase-authentication/ Thu, 19 Sep 2024 11:27:37 +0800 https://springdoc.cn/spring-security-firebase-authentication/ 1、概览 在现代 Web 应用中，用户身份认证和授权是至关重要的组成部分。从零开始构建身份认证层是一项具有挑战性的复杂任务。不过，随着基于云的身份认证服务的兴起，这一过程变得简单多了。 Firebase Authentication 就是这样一个例子，它是 Firebase 和谷歌 提供的一种完全托管的身份认证服务。 本文将带你了解如何将 Firebase Authentication 与 Spring Security 整合，以创建和认证我们的用户。我们要进行必要的配置，实现用户注册和登录功能，并创建一个自定义 Authentication Filter 来验证私有 API 端点的用户 Token。 2、项目设置 在实现之前，需要加入 SDK 依赖并正确配置应用。 2.1、依赖 首先，在项目的 pom.xml 文件中添加 Firebase admin 依赖： <dependency> <groupId>com.google.firebase</groupId> <artifactId>firebase-admin</artifactId> <version>9.3.0</version> </dependency> 该依赖提供了必要的类，用于在应用中与 Firebase Authentication 服务交互。 2.2、定义 Firebase 配置 Bean 现在，为了与 Firebase Authentication 交互，我们需要配置私钥（Private Key）来验证 API 请求。 在本例中，我们在 src/main/resources 目录下创建 private-key.json 文件。不过，在生产中，私钥应从环境变量中加载，或从 secret 管理系统中获取，以提高安全性。 使用 @Value 注解加载私钥，并用它来定义 Bean： @Value("classpath:/private-key.json") private Resource privateKey; @Bean public FirebaseApp firebaseApp() { InputStream credentials = new ByteArrayInputStream(privateKey. https://springdoc.cn/java-message-service-ibm-mq-read-write/ Thu, 19 Sep 2024 10:36:40 +0800 https://springdoc.cn/java-message-service-ibm-mq-read-write/ 1、简介 本文将会带你了解如何使用 Java JMS（Java Message Service）从 IBM MQ 队列读写消息。 2、设置环境 我们可以在 Docker 容器中运行 IBM MQ，以避免手动安装和配置的复杂性。 使用以下命令以基本配置运行容器： docker run -d --name my-mq -e LICENSE=accept -e MQ_QMGR_NAME=QM1 MQ_QUEUE_NAME=QUEUE1 -p 1414:1414 -p 9443:9443 ibmcom/mq 接下来，需要在 pom.xml 文件中添加 IBM MQ 客户端： <dependency> <groupId>com.ibm.mq</groupId> <artifactId>com.ibm.mq.allclient</artifactId> <version>9.4.0.0</version> </dependency> 3、配置 JMS Connection 首先，我们需要用 QueueConnectionFactory 建立 JMS Connection（连接），用于创建与队列管理器（Queue Manager）的连接： public class JMSSetup { public QueueConnectionFactory createConnectionFactory() throws JMSException { MQQueueConnectionFactory factory = new MQQueueConnectionFactory(); factory.setHostName("localhost"); factory.setPort(1414); factory.setQueueManager("QM1"); factory.setChannel("SYSTEM.DEF.SVRCONN"); return factory; } } 首先创建一个 MQQueueConnectionFactory 实例，用于配置和创建与 IBM MQ 服务器的连接。我们将主机名设置为 localhost，因为 MQ 服务器是在本地 Docker 容器内运行的。暴露的映射端口为 1414。 https://springdoc.cn/java-hibernate-change-field-value-before-update-insert/ Tue, 17 Sep 2024 16:46:38 +0800 https://springdoc.cn/java-hibernate-change-field-value-before-update-insert/ 1、概览 在使用 Hibernate 时，经常会遇到这样的情况：在将实体持久化到数据库之前，需要更改字段的值。这种情况可能是因为需要执行必要的字段转换。 本文将通过一个示例：即在执行更新和插入操作前将字段值转换为大写字母，来了解实现这一目的的不同方法。 2、实体生命周期回调 首先，定义一个简单的实体类 Student： @Entity @Table(name = "student") public class Student { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; @Column private String name; // Getter / Setter 方法省略 } 第一种方法是 JPA 实体生命周期回调。JPA 提供了一组注解，允许我们在不同的 JPA 生命周期事件中执行一个方法，例如： @PrePresist：在插入事件之前执行。 @PreUpdate：在更新事件之前执行。 我们在 Student 实体类中添加 changeNameToUpperCase() 方法。该方法将 name 字段改为大写。该方法通过 @PrePersist 和 @PreUpdate 进行注解，以便 JPA 在持久化和更新之前调用该方法： @Entity @Table(name = "student") public class Student { @PrePersist @PreUpdate private void changeNameToUpperCase() { name = StringUtils. https://springdoc.cn/spring-boot-httpstatuscode/ Tue, 17 Sep 2024 15:22:03 +0800 https://springdoc.cn/spring-boot-httpstatuscode/ 1、概览 本文将带你了解如何在 Spring Boot 应用中使用 HttpStatusCode，重点是 3.3.3 版中引入的最新增强功能。通过这些增强功能，HttpStatusCode 已被纳入 HttpStatus 实现，从而简化了我们处理 HTTP 状态码的方式。 这些改进的主要目的是提供一种更灵活、更可靠的方法来处理标准和自定义 HTTP 状态码，使我们在处理 HTTP 响应时具有更高的灵活性和可扩展性，同时保持向后兼容性。 2、HttpStatus 枚举 在 Spring 3.3.3 之前，HTTP 状态码在 HttpStatus 中表示为枚举。这限制了自定义或非标准 HTTP 状态码的使用，因为枚举是一组固定的预定义值。 尽管 HttpStatus 类尚未被弃用，但一些返回原始 Integer 状态码的枚举和方法（如 getRawStatusCode() 和 rawStatusCode()）现已被弃用。 使用 @ResponseStatus 注解来提高代码的可读性仍然是我们推荐的方法。 我们可以将 HttpStatus 与 HttpStatusCode 结合使用，以实现更灵活的 HTTP 响应管理： @GetMapping("/exception") public ResponseEntity<String> resourceNotFound() { HttpStatus statusCode = HttpStatus.NOT_FOUND; if (statusCode.is4xxClientError()) { return new ResponseEntity<>("Resource not found", HttpStatusCode.valueOf(404)); } return new ResponseEntity<>("Resource found", HttpStatusCode. https://springdoc.cn/java-netbeans-use-profiler-programmatically/ Tue, 17 Sep 2024 14:25:00 +0800 https://springdoc.cn/java-netbeans-use-profiler-programmatically/ 1、概览 对应用程序进行分析可以深入了解其运行时的行为。Java 生态系统中有多种流行的分析器（Profiler），如用于通用分析的 NetBeans Profiler、JProfiler 和 VisualVM。 本文将带你了解如何以编程方式使用 NetBeans profiler API。 2、NetBeans Profiler NetBeans IDE 提供免费的分析器来分析 Java 应用。它通过 IDE 中直观的嵌入式用户界面，提供了评估 CPU 性能和内存使用情况的功能。 然而，NetBeans Profiler 还提供了可用于编程式的分析 API。这可用于 Heap Dump 的自动化分析，而不需要依赖于 UI 界面。 Heap Dump（堆转储）是一段时间内应用的内存快照。它是深入了解内存使用情况的良好指标，因为它包括内存中的实时对象、对象的类和字段以及对象之间的引用。 3、示例项目 要使用 NetBeans Profiler API，首先在 pom.xml 中添加 依赖： <dependency> <groupId>org.netbeans.modules</groupId> <artifactId>org-netbeans-lib-profiler</artifactId> <version>RELEASE220</version> </dependency> 该依赖提供了 JavaClasses 和 Instances 等各种工具类，以帮助我们分析类、创建的实例数量和使用的内存。 接着，创建一个简单的项目并分析它的 Heap Dump： class SolarSystem { private static final Logger LOGGER = Logger.getLogger(SolarSystem.class.getName()); private int id; private String name; private List<String> planet = new ArrayList<>(); // 构造函数 public void logSolarSystem() { LOGGER. https://springdoc.cn/spring-jdbctemplate-stored-procedure/ Thu, 12 Sep 2024 09:56:02 +0800 https://springdoc.cn/spring-jdbctemplate-stored-procedure/ 1、概览 本文将带你了解如何使用 Spring JDBC 框架的 JdbcTemplate 来调用存储过程。数据库存储过程类似于函数。函数支持输入参数并有返回类型，而存储过程同时支持输入和输出参数。 2、先决条件 来看看 PostgreSQL 数据库中一个简单的存储过程： CREATE OR REPLACE PROCEDURE sum_two_numbers( IN num1 INTEGER, IN num2 INTEGER, OUT result INTEGER ) LANGUAGE plpgsql AS ' BEGIN sum_result := num1 + num2; END; '; 存储过程 sum_twoo_numbers 接收两个输入数字，并在输出参数 sum_result 中返回它们的和。一般来说，存储过程可以支持多个输入和输出参数。但在本例中，我们只考虑了一个输出参数。 3、使用 JdbcTemplate#call() 方法 来看看如何使用 JdbcTemplate#call() 方法调用数据库存储过程： void givenStoredProc_whenCallableStatement_thenExecProcUsingJdbcTemplateCallMethod() { List<SqlParameter> procedureParams = List.of(new SqlParameter("num1", Types.INTEGER), new SqlParameter("num2", Types.NUMERIC), new SqlOutParameter("result", Types.NUMERIC) ); Map<String, Object> resultMap = jdbcTemplate.call(new CallableStatementCreator() { @Override public CallableStatement createCallableStatement(Connection con) throws SQLException { CallableStatement callableStatement = con. https://springdoc.cn/jpa-cast-vs-treat/ Tue, 10 Sep 2024 10:39:43 +0800 https://springdoc.cn/jpa-cast-vs-treat/ 1、简介 在 JPA 中，CAST 和 TREAT 是两个不同的关键字，用于操作数据类型和实体关系。本文将带你了解 CAST 和 TREAT 的区别，并通过示例来说明它们的用法。 2、JPA 中的 CAST JPA 中的 CAST 操作符主要用于 JPQL 查询中的类型转换。它允许我们显式地将一个值从一种数据类型转换为另一种数据类型。例如，可以使用 CAST 将字符串转换为整数，反之亦然。 CAST 的语法如下： CAST(expression AS type) expression 是我们要转换的值或字段，type 是我们要将表达式转换为的目标数据类型。 3、JPA 中的 TREAT 相比之下，TREAT 操作符是为在 JPQL 查询中对实体进行类型安全的向下转换而设计的。它在处理继承层次结构时特别有用。使用 TREAT 时，我们指定实体的子类型，然后 JPA 会检查实际实体是否确实属于该类型。 与 CAST 不同，TREAT 不会改变值的底层数据类型。相反，它允许我们像访问目标类型的值一样访问该值。 TREAT 的语法如下: TREAT(expression AS type) expression 是要处理的值，type 是目标数据类型。 4、适用场景和用法 在 JPA 查询中，CAST 和 TREAT 都用于处理类型转换，但它们的用途不同。 4.1、CAST 操作符 CAST 用于将一种数据类型转换为另一种数据类型，以便进行操作或比较。在执行查询时，如果需要的数据类型与数据库中存储的数据类型不同，通常会使用 CAST。 示例如下：一个名为 Employee 的实体，其 salary 字段在数据库中存储为字符串。下面是 Employee 实体的定义： https://springdoc.cn/spring-reactive-switchifempty/ Tue, 10 Sep 2024 10:01:03 +0800 https://springdoc.cn/spring-reactive-switchifempty/ 1、概览 本文将带你了解 Spring Reactive 中的 switchIfEmpty() 操作符及其在使用和不使用 defer() 操作符时的行为，了解这些操作符在不同场景中的交互方式，并通过实际示例来说明它们对响应式流（Reactive Stream）的影响。 2、switchIfEmpty() 和 Defer() 的使用 switchIfEmpty() 是 Mono 和 Flux 中的一个操作符，用于在源生产者为空时执行备用生产者流。如果主源 Publisher 没有发布数据，该操作符就会切换到替代源的数据发布。 考虑一个从大型文件中通过 ID 检索用户详细信息的场景。当请求文件中的用户详细信息时，遍历文件会消耗大量时间。因此，对于经常访问的 ID，将其详细信息缓存起来更有意义。 当端点收到请求时，首先搜索缓存。如果用户详细信息可用，返回响应。如果没有，则从文件中获取数据并缓存起来，以备后续请求。 在这种情况下，主数据提供者（Primary Data Provider）是检查缓存中 KEY 是否存在的流，而备用数据提供者是检查文件中的 KEY 并更新缓存的流。switchIfEmpty() 操作符可以根据缓存中数据的可用性高效地切换数据源提供者。 了解 defer() 操作符的使用也很重要，它可以推迟函数的求值，直到发生订阅。如果我们不在 switchIfEmpty() 中使用 defer() 操作符，表达式就会立即（急切地）求值，从而可能导致意想不到的副作用。 3、示例设置 通过示例来了解 switchIfEmpty() 操作符在不同情况下的行为。 3.1、Data Model 首先，定义一个 User 模型类，其中包含一些详细信息，如 id、email、username 和 roles： public class User { @JsonProperty("id") private String id; @JsonProperty("email") private String email; @JsonProperty("username") private String username; @JsonProperty("roles") private String roles; // Getter / Setter 省略 } 3. https://springdoc.cn/java-webclient-synchronous-requests/ Thu, 05 Sep 2024 11:25:07 +0800 https://springdoc.cn/java-webclient-synchronous-requests/ 1、简介 本文将会带你了解如何使用 WebClient 执行同步请求。 在响应式编程日益普及的同时，在哪些情况下这种阻塞式请求仍然是适当和必要的？ 2、Spring 中的 HTTP 客户端库概述 首先，回顾一下目前可用的客户端库。 在 Spring Framework 3.0 中引入 RestTemplate 时，其简单的 HTTP 请求模板方法 API 广受欢迎。然而，其同步性质和许多重载方法在高流量应用程序中导致了复杂性和性能瓶颈。 在 Spring 5.0 中，WebClient 被引入作为一种更高效、响应式的选择，用于非阻塞请求。尽管它是 Reactive Stack Web 框架的一部分，但它支持用于同步和异步通信的 Fluent 风格的 API。 在 Spring Framework 6.1 中，RestClient 提供了另一种执行 REST 调用的选项。它将 WebClient 的 Fluent API 与 RestTemplate 的基础设施结合在一起，包括消息转换器、请求工厂和拦截器。 尽管 RestClient 针对同步请求进行了优化，但如果我们的应用还需要异步或流式传输功能，则 WebClient 更为适用。通过在阻塞和非阻塞 API 调用中使用 WebClient，我们可以保持代码库的一致性，避免混用不同的客户端库。 3、阻塞与非阻塞 API 调用 在介绍各种 HTTP 客户端时，我们使用了同步和异步、阻塞和非阻塞等术语。这些术语与上下文有关，有时可能代表同一概念的不同名称。 在方法调用方面，WebClient 根据发送和接收 HTTP 请求和响应的方式，支持同步和异步交互。如果 WebClient 等待前一个请求完成后才继续处理后一个请求，则是以阻塞方式进行的，而结果是同步返回的。 另一方面，我们可以通过执行立即返回的非阻塞调用来实现异步交互。在等待另一个系统的响应时，其他处理工作可以继续进行，一旦准备就绪，就会以异步方式提供结果。 4、什么情况下使用同步请求 如前所述，WebClient 是 Spring Webflux 框架的一部分，默认情况下一切都是响应式的。不过，该库提供异步和同步操作支持，因此适用于响应式和 Servlet Stack Web 应用。 https://springdoc.cn/gradle-exclude-transitive-dependencies/ Thu, 05 Sep 2024 10:23:18 +0800 https://springdoc.cn/gradle-exclude-transitive-dependencies/ 1、概览 Gradle 是一款构建自动化工具，用于管理和自动化应用程序的构建、测试和部署过程。 使用基于 Groovy 或 Kotlin 的 DSL（Domain-Specific Language）来定义构建任务，可以轻松地自动定义和管理项目中所需的依赖。 本文将带你了解在 Gradle 中排除传递依赖的几种方法。 2、传递依赖是什么？ 假设我们使用的 A 依赖于另一个库 B。默认情况下，当我们包含 A 时，Gradle 会自动将 B 添加到项目的 classpath 中，这样，即使我们没有明确地将 B 添加为依赖，也可以在项目中使用 B 的代码。 来看一个实际的例子，在项目中定义 Google Guava 依赖： dependencies { // ... implementation 'com.google.guava:guava:31.1-jre' } 如果 Google Guava 与其他库存在依赖关系，那么 Gradle 会自动包含这些其他库。 要查看项目中使用的依赖项，可以使用如下命令将其打印出来： ./gradlew <module-name>:dependencies 假设我们的模块名为 excluding-transitive-dependencies： ./gradlew excluding-transitive-dependencies:dependencies 输出如下： testRuntimeClasspath - Runtime classpath of source set 'test'. \--- com.google.guava:guava:31.1-jre +--- com.google.guava:failureaccess:1.0.1 +--- com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava +--- com.google.code.findbugs:jsr305:3.0.2 +--- org. https://springdoc.cn/spring-data-dynamicinsert/ Wed, 04 Sep 2024 10:40:34 +0800 https://springdoc.cn/spring-data-dynamicinsert/ 1、概览 Spring Data JPA 中的 @DynamicInsert 注解通过在 SQL 语句中只包含非 null 字段来优化插入操作。这一过程加快了结果查询的速度，减少了不必要的数据库交互。 虽然它提高了对具有许多可为空字段的实体的效率，但也引入了一些运行时开销。因此，在只有在排除空列的好处超过性能成本的情况下，有选择地使用它。 2、JPA 中 INSERT 的默认行为 使用 EntityManager 或 Spring Data JPA 的 save() 方法持久化 JPA 实体时，Hibernate 会生成一条 SQL 插入（INSERT）语句。该语句包括每个实体列，即使某些列包含 null 值。因此，在处理包含许多可选字段的大型实体时，插入操作的效率会很低。 先来看一个简单的 Account 实体： @Entity public class Account { @Id private int id; @Column private String name; @Column private String type; @Column private boolean active; @Column private String description; // Getter / Setter } 为 Account 实体创建 JPA Repository： https://springdoc.cn/docker-maven-build-multi-module-projects/ Wed, 04 Sep 2024 09:58:28 +0800 https://springdoc.cn/docker-maven-build-multi-module-projects/ 1、概览 本文将带你了解如何利用 Docker 的多阶段构建功能高效地为多模块 Maven 项目构建 Docker 镜像，，以充分利用 Docker 的缓存机制。 然后，还会介绍 Google Jib Maven 插件，用于在没有 Dockerfile 或 Docker 的情况下构建 Docker 镜像。 2、多模块 Maven 项目 多模块 Maven 应用由不同功能的独立模块组成。Maven 通过管理依赖关系来构建应用，并将这些模块组装成一个可部署的单元。 在本文的代码示例中，我们将使用一个包含两个 Maven 模块的基本 Spring Boot 项目，这两个模块分别代表应用程序的 Domain 和 API。 Maven 项目的结构如下： +-- parent +-- api | `-- src | `-- pom.xml +-- domain | `-- src | `-- pom.xml `-- pom.xml 查看父模块的 pom.xml 文件，就会发现它继承了 spring-boot-starter-parent，并包含了 domain 和 api 模块： <project> <groupId>com.baeldung.docker-multi-module-maven</groupId> <artifactId>parent</artifactId> <packaging>pom</packaging> <version>0. https://springdoc.cn/java-reflection-accessflag-modifiers/ Tue, 03 Sep 2024 13:56:18 +0800 https://springdoc.cn/java-reflection-accessflag-modifiers/ 1、概览 Java 中的反射是一个强大的功能，它允许我们操纵不同的成员，如类、接口、字段和方法。此外，使用反射，我们可以在编译时实例化类、调用方法和访问字段，而无需知道类型。 本文将带你了解如何使用 JVM AccessFlag（访问标志），以及 Modifier 和 AccessFlag 之间的区别。 2、JVM AccessFlag Java 虚拟机规范 定义了 JVM 中已编译类的结构，它由一个 ClassFile 组成： ClassFile { u4 magic; u2 minor_version; u2 major_version; u2 constant_pool_count; cp_info constant_pool[constant_pool_count-1]; u2 access_flags; u2 this_class; u2 super_class; u2 interfaces_count; u2 interfaces[interfaces_count]; u2 fields_count; field_info fields[fields_count]; u2 methods_count; method_info methods[methods_count]; u2 attributes_count; attribute_info attributes[attributes_count]; } 除其他项目外，ClassFile 还包含 access_flags 项。简而言之，access_flags 是一个掩码，由定义类的访问权限和其他属性的各种标志组成。 此外，ClassFile 还包括 field_info 和 method_info 项，每个项都包含其 access_flags 项。 Javassist 和 ASM 等库使用 JVM AccessFlag 来操作 Java 字节码。 https://springdoc.cn/spring-boot-properties-dynamic-update/ Thu, 29 Aug 2024 11:39:20 +0800 https://springdoc.cn/spring-boot-properties-dynamic-update/ 1、概览 动态管理应用程序配置是许多实际应用场景中的关键要求。在微服务架构中，由于扩展操作或负载条件的变化，不同的服务可能需要即时更改配置。在其他情况下，应用程序可能需要根据用户偏好、来自外部 API 的数据调整其行为，或满足动态变化的要求。 application.properties 文件是静态的，在不重启应用的情况下无法更改。不过，Spring Boot 提供了几种强大的方法，可在运行时调整配置而无需停机。无论是在实时应用程序中切换功能、更新数据库连接以实现负载均衡，还是在不重新部署应用的情况下更改第三方集成的 API Key，Spring Boot 的动态配置功能都能为这些复杂的环境提供所需的灵活性。 本文将带你了解几种无需直接修改 application.properties 文件即可动态更新 Spring Boot 应用程序中属性的策略。这些方法可满足不同的需求，从非持久性内存更新到使用外部文件进行持久性更改。 本文中的示例使用 Spring Boot 3.2.4、JDK17 以及 Spring Cloud 4.1.3。不同版本的 Spring Boot 可能需要对代码进行轻微调整。 2、使用 Prototype Scope Bean 当我们需要动态调整特定 Bean 的属性，而不影响已创建的 Bean 实例或更改全局应用程序状态时，一个简单的使用 @Value 直接注入的 @Service 类是不够的，因为这些属性在 Application Context 的生命周期内是静态的。 相反，可以使用 @Configuration 类中的 @Bean 方法创建具有可修改属性的 Bean。这种方法允许在应用程序执行过程中动态更改属性： @Configuration public class CustomConfig { @Bean @Scope("prototype") // Scope 为 prototype public MyService myService(@Value("${custom.property:default}") String property) { return new MyService(property); } } 通过使用 @Scope("prototype") 注解，我们可以确保每次调用 myService(. https://springdoc.cn/java-servlet-post-request-payload/ Thu, 29 Aug 2024 10:28:44 +0800 https://springdoc.cn/java-servlet-post-request-payload/ 1、简介 Java Servlet 是一个服务端组件，用于处理客户端传入的 HTTP 请求，通常我们需要通过 Servlet 中的 HttpServletRequest 对象来获取到客户端提交的请求数据。 本文将带你了解在 Java Servlet 中读取 Payload（即请求体）数据的各种方法，以及最佳实践和注意事项。 2、理解 Request Payload Post 请求主要用于通过 HTTP 请求向服务器发送数据。这些数据可以是任何内容，从包含用户输入的表单数据到结构化数据如 JSON 和 XML，甚至是二进制文件。这些数据位于请求体中，与 URL 分开。这样可以实现更广泛和安全的数据传输。我们可以通过请求中的 Content-Type Header 标识不同类型的数据。 常见的 Content-Type 包括： application/x-www-form-urlencoded：用于以键值对形式编码的表单数据 application/json：用于 JSON 格式的数据 application/xml：用于 XML 格式的数据 text/plain：用于发送纯文本 multipart/form-data：用于上传二进制文件和常规表单数据（form data） 3、读取 Post 请求体的方式 接下来，让我们看看从 POST Payload 中提取数据的不同方法。 3.1、使用 getParameter() 获取 URL 编码的表单数据 我们可以使用 HttpServletRequest 接口提供的 getParameter() 方法，使用通过 POST 请求提交的参数名检索特定表单数据。该方法使用表单参数名作为参数，并以字符串（String）形式返回相应的值。 举个例子： @WebServlet(name = "FormDataServlet", urlPatterns = "/form-data") public class FormDataServlet extends HttpServlet { @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException { String firstName = StringEscapeUtils. https://springdoc.cn/spring-fallback-beans/ Thu, 29 Aug 2024 09:56:04 +0800 https://springdoc.cn/spring-fallback-beans/ 1、概览 本文将带你了解 Spring 中 Fallback Bean 的概念。 Fallback Bean 是在 Spring Framework 6.2.0-M1 中引入的，当另一个相同类型的 Bean 不可用或无法初始化时，它提供了一种替代实现。 2、Primary Bean 和 Fallback Bean 在 Spring 中，我们可以定义多个相同类型的 Bean。默认情况下，Spring 使用 Bean 名称和类型来标识 Bean。当有多个名称和类型相同的 Bean 时，可以使用 @Primary 注解将其中一个标记为 Primary（主要）Bean，使其优先于其他 Bean。如果在 Application Context 初始化时创建了多个相同类型的 Bean，而我们又想指定默认使用哪个 Bean，那么这就非常有用了。 同样，我们可以定义一个 Fallback Bean，以便在没有其他合格 Bean 时提供替代实现。我们可以使用 @Fallback 注解将一个 Bean 标记为 Fallback（后备） Bean。只有当没有其他同名的 Bean 可用时，才会将后备 Bean 注入到 Application Context。 3、示例代码 来看一个示例，演示如何在 Spring 应用中使用 Primary Bean 和 Fallback Bean。 我们要创建一个使用不同 MQ 服务发送消息的小应用。假设我们在生产环境和非生产环境中拥有多个 MQ 服务，并且需要在它们之间切换以优化性能和成本。 https://springdoc.cn/structured-logging-in-spring-boot-3-4/ Tue, 27 Aug 2024 12:02:18 +0800 https://springdoc.cn/structured-logging-in-spring-boot-3-4/ 日志记录是应用故障排除的重要组成部分，也是可观测性的三大支柱之一，另外两个是指标和追踪（Trace）。没有人喜欢在生产环境中瞎操作，当事故发生时，开发者会很乐意看到日志文件。日志通常以人类可读的格式输出。 结构化日志是一种技术，其中日志输出以定义良好的格式编写，通常是机器可读的。这种格式可以输入到日志管理系统中，从而实现强大的搜索和分析功能。结构化日志最常用的格式之一是 JSON。 Spring Boot 3.4 开箱即支持结构化日志。它支持 Elastic Common Schema（ECS）和 Logstash 格式，也可以使用自己的格式进行扩展。 结构化日志的 Hello World 在 start.springboot.io 上创建一个新项目，不需要添加任何依赖，但至少要选择 Spring Boot 3.4.0-M2。 要在控制台上启用结构化日志记录，请将如下配置添加到 application.properties 中： logging.structured.format.console=ecs 这将指示 Spring Boot 以 Elastic Common Schema（ECS） 格式输出日志。 启动应用，你就会看到日志是 JSON 格式的： {"@timestamp":"2024-07-30T08:41:10.561295200Z","log.level":"INFO","process.pid":67455,"process.thread.name":"main","service.name":"structured-logging-demo","log.logger":"com.example.structured_logging_demo.StructuredLoggingDemoApplication","message":"Started StructuredLoggingDemoApplication in 0.329 seconds (process running for 0.486)","ecs.version":"8.11"} 将结构化日志记录到文件 你还可以将结构化日志写入文件。例如，这可以用于在控制台上打印人类可读的日志，同时将结构化日志写入文件以供机器读取。 要启用此功能，请将如下配置添加到 application.properties 中，并确保删除 logging.structured.format.console=ecs 设置： logging.structured.format.file=ecs logging.file.name=log.json 现在启动应用，你会看到控制台上有人类可读的日志，而 log.json 文件则包含机器可读的 JSON 内容。 添加额外字段 结构化日志的一个强大功能是，开发人员可以以结构化的方式在日志事件中添加信息。例如，你可以在每个日志事件中添加用户 ID，然后根据该 ID 进行过滤，查看这个特定用户做了什么。 Elastic Common Schema 和 Logstash 都在 JSON 中包含了 Mapped Diagnostic Context 的内容。 https://springdoc.cn/spring-cloud-gateway-integrate-openapi/ Tue, 27 Aug 2024 11:25:20 +0800 https://springdoc.cn/spring-cloud-gateway-integrate-openapi/ 1、概览 文档是构建任何健壮的 REST API 的重要部分。我们可以基于 OpenAPI 规范实现 API 文档，并在 Spring 应用中使用 Swagger UI 进行可视化展示。 此外，由于 API 端点可以通过 API 网关公开，我们还需要将后端服务的 OpenAPI 文档与网关服务集成。网关服务将提供所有 API 文档的汇总视图。 本文将带你了解如何在 Spring 应用中集成 OpenAPI，以及如何使用 Spring Cloud Gateway 服务公开后端服务的 API 文档。 2、示例应用 假设我们需要构建一个简单的微服务来获取一些数据。 2.1、Maven 依赖 首先，添加 spring-boot-starter-web 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>3.3.2</version> </dependency> 2.2、实现 REST API 我们的后端应用有一个端点返回 Product 数据。 首先，创建 Product 类： public class Product { private long id; private String name; // 标准 Getter / Setter } 接下来，在 ProductController 中实现 getProduct 端点： https://springdoc.cn/spring-dynamic-client-registration/ Tue, 27 Aug 2024 10:03:08 +0800 https://springdoc.cn/spring-dynamic-client-registration/ 1、简介 Spring Authorization Server（授权服务器）自带一系列合理的默认设置，开箱即用。 但是，它还有一个功能，默认下没有启动：态客户端注册。本文将带你了解如何在客户端应用中启用和使用它。 2、为什么使用动态注册？ 当基于 OAuth2 的客户端应用（在 OIDC 术语中称为依赖方）启动认证流程时，它将自己的客户端标识符发送给身份提供者（Provider）。 一般情况下，这个标识符是通过外部流程（如邮件发送等其他手段）发放给客户端的，客户端随后将其添加到配置中，并在需要时使用。 例如，在使用 Azure 的 EntraID 或 Auth0 等流行的身份提供商（Identity Provider）解决方案时，我们可以使用管理控制台或 API 来配置新客户端。在此过程中，我们需要告知应用名称、授权回调 URL、支持的作用域等信息。 提供所需信息后，我们会得到一个新的客户端标识符，对于所谓的 “secret” 客户端，还将得到一个 client secret。然后，我们将这些信息添加到应用的配置中，就可以开始部署了。 现在，当我们应用不多，或者总是使用单一的一个身份供应商时（Identity Provider），这种方式就能正常工作。但对于更复杂的情况，注册过程需要是动态的，这就是 OpenID Connect 动态客户端注册规范 的用武之地。 在现实世界中，英国的 OpenBanking 标准就是一个很好的例子，该标准将动态客户注册作为其核心协议之一。 3、动态注册是如何实现的？ OpenID Connect 标准使用一个注册 URL，客户端使用该 URL 注册自己。注册是通过 POST 请求完成的，该请求包含一个 JSON 对象，其中有执行注册所需的客户端元数据。 重要的是，访问注册端点需要身份认证，通常是一个 Bearer Token。当然，这就引出了一个问题：想成为客户端的人如何获得用于此操作的 Token？ 遗憾的是，答案并不明确。一方面，规范指出端点是受保护的资源，因此需要某种形式的身份认证。另一方面，它也提到了开放注册端点的可能性。 对于 Spring 授权服务器来说，注册需要一个具有 client.create scope 的 Bearer Token。要创建该令牌，我们需要使用常规 OAuth2 的 Token 端点和基本凭证。 动态注册的流程如下： 客户端注册成功后，就可以使用返回的客户端 ID 和 secret secret 执行任何标准授权流程。 https://springdoc.cn/java-jdbc-preparedstatement-in-clause/ Sun, 25 Aug 2024 13:24:32 +0800 https://springdoc.cn/java-jdbc-preparedstatement-in-clause/ 1、简介 在数据库 SQL 查询中，我们经常使用 IN 语句来一次性检索匹配多个值的记录，本文将带你了解如何在 JDBC PreparedStatement 中使用 IN 子句。 2、设置 创建一个 CUSTOMER 表，并添加一些记录，以便使用 IN 子句进行查询： void populateDB() throws SQLException { String createTable = "CREATE TABLE CUSTOMER (id INT, first_name VARCHAR(50), last_name VARCHAR(50))"; connection.createStatement().execute(createTable); String load = "INSERT INTO CUSTOMER (id, first_name, last_name) VALUES(?,?,?)"; IntStream.rangeClosed(1, 100) .forEach(i -> { PreparedStatement preparedStatement1 = null; try { preparedStatement1 = connection.prepareStatement(load); preparedStatement1.setInt(1, i); preparedStatement1.setString(2, "firstname" + i); preparedStatement1.setString(3, "lastname" + i); preparedStatement1.execute(); } catch (SQLException e) { throw new RuntimeException(e); } }); } 3、PreparedStatement PreparedStatement 表示一个已经预编译的 SQL 语句，可以高效地多次使用，每次使用可以填充不同的参数。 https://springdoc.cn/java-maven-environment-variables/ Sun, 25 Aug 2024 12:56:46 +0800 https://springdoc.cn/java-maven-environment-variables/ 1、概览 在 Apache Maven 安装的过程中，我们需要配置各种环境变量，以确保 Maven 能正常运行。本文将带你了解与之相关的三个变量：M2_HOME、MAVEN_HOME 和 PATH。 先来看看如何配置最早版本的 Maven。 注意：Apache Maven 1.x 和 Maven 2.x 已停止使用。第 2 节和第 3 节展示的配置仅供参考，不提倡使用。 2、Maven 1.x 下载并解压 Maven 压缩文件，进入到解压目录的 bin 文件夹。在这个目录中，你可以尝试执行一下 maven 命令，看看它是否能正常工作： $ maven -v 该命令输出如下，表示我们缺少一个必需的环境变量： MAVEN_HOME must be set MAVEN_HOME 环境变量指定了 Maven 目录（解压后的）的位置，而且该环境变量是必须的。 在系统中添加这个环境变量后，再次运行之前的命令（需要新的终端中运行）： $ maven -v 结果如下： __ __ | \/ |__ _Apache__ ___ | |\/| / _` \ V / -_) ' \ ~ intelligent projects ~ |_| |_\__,_|\_/\___|_||_| v. https://springdoc.cn/poi-tl-ms-word/ Sat, 24 Aug 2024 17:59:44 +0800 https://springdoc.cn/poi-tl-ms-word/ 1、概览 poi-tl 是一个基于 Apache POI 的开源 Java 库，用于简化使用模板生成 Word 文档的过程。它是一个 Word 模板引擎，可根据 Word 模板和数据创建新文档。 我们可以在模板中指定样式。从模板生成的文档将保留指定的样式。模板是声明式的，纯粹基于标签，图片、文本、表格等都有不同的标签模式。poi-tl 库还支持自定义插件，以根据需要构建文档。 本文将带你了解模板中可以使用的不同标签，以及模板中自定义插件的用法。 2、依赖 要使用 poi-tl 库，我们需要在项目中添加其 maven 依赖： <dependency> <groupId>com.deepoove</groupId> <artifactId>poi-tl</artifactId> <version>1.12.2</version> </dependency> 你在 Maven Central 中找到最新版本的 poi-tl 库。 3、配置 使用 ConfigureBuilder 类来构建配置： ConfigureBuilder builder = Configure.builder(); ... XWPFTemplate template = XWPFTemplate.compile(...).render(templateData); template.writeAndClose(...); 模板文件是以 Word .docx 文件格式保存的。首先，我们使用 XWPFTemplate 类的 compile 方法对模板进行编译。模板引擎编译模板，并根据 templateData 在新的 docx 文件中进行渲染。在这里，writeAndClose 创建一个新文件，并按照模板中指定的格式写入指定的数据。templateData 是一个 HashMap 的实例，其中 Key 为 String，值为 Object。 我们可以根据自己的需要配置模板引擎。 3.1、标签前缀和后缀 模板引擎使用大括号 {{}} 表示标签。我们可以将其设置为 ${} 或其他任何形式： https://springdoc.cn/spring-boot-3-3-3-available-now/ Fri, 23 Aug 2024 13:24:28 +0800 https://springdoc.cn/spring-boot-3-3-3-available-now/ Spring Boot v3.3.3 发布了。 ⭐ 新特性 在 JavaVersion 枚举中添加 TWENTY_THREE #41716 🐞 Bug 修复 继承 DefaultErrorAttributes 并覆写 getErrorAttributes() 会被调用两次 #41995 在使用 WebFlux 时，当 ResponseStatusException 的原因是 BindingResult 异常时，server.error.include-binding-errors=ALWAYS 不生效 #41987 将 BOOT-INF/lib 中的 jar 添加到 classpath 时，PropertiesLauncher 不遵循 classpath.idx #41970 /cloudfoundryapplication 下 SBOM 端点的 Web 扩展不可用 #41890 启动器（Launcher）的 ClassLoader 不再具有并行功能 #41873 spring-boot-testcontainers 会在 AOT 处理过程中导致不必要的容器初始化 #41859 当 Reactor 不在类路径上时，ReactiveElasticsearchRepositoriesAutoConfiguration 应关闭 #41678 当 classifier 设置为非默认值时，mvn spring-boot:build-image 失败 #41661 Spring Boot Maven 插件 AOT 无法使用 module-info. https://springdoc.cn/hibernate-insert-query-on-conflict-clause/ Fri, 23 Aug 2024 12:37:17 +0800 https://springdoc.cn/hibernate-insert-query-on-conflict-clause/ 1、概览 本文将带你了解 Hibernate 6.5 中引入的用于 INSERT 查询的 ON CONFLICT 子句。 我们使用 ON CONFLICT 子句来处理使用 HQL 或 Criteria 查询插入数据时违反表约束的情况。ON CONFLICT 子句也可以用于处理 upsert 查询。 2、ON CONFLICT 子句 使用 ON CONFLICT 子句进行 insert 的语法如下： "INSERT" "INTO"? targetEntity targetFields (queryExpression | valuesList) conflictClause? conflictClause 的写法为： "on conflict" conflictTarget? conflictAction conflictAction（冲突操作）可以是 DO NOTHING 或者 DO UPDATE。 现在，来看一个例子。假设实体类 Student 的属性有 studentId 和 name： @Entity public class Student { @Id private long studentId; private String name; } studentId 属性是 Student 实体的唯一键。我们可以在 INSERT VALUES 查询中手动插入 @Id 值，或者使用 @GeneratedValue 注解来指定 ID 的生成策略。 https://springdoc.cn/java-quarkus-mongodb/ Thu, 22 Aug 2024 11:00:01 +0800 https://springdoc.cn/java-quarkus-mongodb/ 1、简介 Quarkus 是一个流行的 Java 框架，经过优化，可用于创建内存占用小、启动速度极快的应用。 与流行的 NoSQL 数据库 MongoDB 搭配使用时，Quarkus 为开发高性能、可扩展的应用提供了强大的工具包。 本文将带你了解如何使用 Quarkus 配置 MongoDB、实现基本的 CRUD 操作，以及如何使用 Quarkus 的 Panache（Object Document Mapper，ODM）来简化这些操作。 2、配置 2.1、Maven 依赖 要在 Quarkus 中使用 MongoDB，需要添加 quarkus-mongodb-client 依赖： <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-mongodb-client</artifactId> <version>3.13.0</version> </dependency> 该依赖提供了使用 MongoDB Java 客户端与 MongoDB 数据库交互的必要工具。 2.2、运行 MongoDB 数据库 本文采用 Docker 的方式运行 MongoDB，这种方式非常便捷，无需在机器上直接安装 MongoDB。 从 Docker Hub 拉取 MongoDB 镜像： docker pull mongo:latest 启动一个新的容器： docker run --name mongodb -d -p 27017:27017 mongo:latest 2.3、配置 MongoDB 数据库 要配置的主要属性是访问 MongoDB 的 URL。我们可以在 connection 字符串中包含几乎所有的配置。 https://springdoc.cn/kafka-emit-key-value-message-cli/ Thu, 22 Aug 2024 10:25:07 +0800 https://springdoc.cn/kafka-emit-key-value-message-cli/ 1、概览 本文将带你了解从 Kafka 命令行（CLI）发送 Key/Value 消息的两种方法。 在处理金融交易、预订、在线购物等实时事件驱动系统中，确保特定 Topic 上消息的有序性是一个常见需求。在这种情况下，我们应该为发送到这些 Topic 的事件使用 Kafka Message Key。 2、先决条件 首先，需要一个正在运行的 Kafka 实例。如果没有，可以使用 Kafka Docker 或根据 Kafka 快速入门指南 建立一个环境。下面的章节将假定我们已经有一个运行中的 Kafka 实例，且可以通过 kafka-server:9092 访问。 接下来，假设我们开发的是一个 “支付系统”，而且需要从命令行发送消息。 以下是对应的 Model 类： // 支付事件 public class PaymentEvent { private String reference; private BigDecimal amount; private Currency currency; // 标准的 Getter / Setter 方法 } 另一个前提条件是要有访问 Kafka CLI 工具的权限，这很简单。首先，下载 Kafka 发行版，然后解压下载的文件，并进入解压后的文件夹中。在 bin 文件夹下就可以找到 Kafka CLI 工具。 本文后面内容中的所有 CLI 命令，都假设是在 Kafka 解码文件夹下执行的。 https://springdoc.cn/spring-ai-with-nvidia-llm-api/ Tue, 20 Aug 2024 19:38:40 +0800 https://springdoc.cn/spring-ai-with-nvidia-llm-api/ Spring AI 现在支持 NVIDIA®（英伟达™）的 大型语言模型 API，可与各种 模型 集成。通过利用 NVIDIA 的 OpenAI 兼容 API，Spring AI 允许开发人员通过熟悉的 Spring AI API 使用 NVIDIA LLM。 本文将带你了解如何配置和使用 Spring AI OpenAI 聊天客户端来连接 NVIDIA LLM API。 完整的示例代码可从 nvidia-llm GitHub 仓库获取。 SpringAI / NVIDIA 整合文档。 先决条件 创建 NVIDIA 帐户并获得足够的积分。 从 NVIDIA 提供的 LLM 模型 中选择自己喜欢的模型。如下面截图中的 meta/llama-3.1-70b-instruct。 从模型页面获取所选模型的 API Key。 依赖 首先，将 Spring AI OpenAI Starter 添加到 Maven pom.xml 中： <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-openai-spring-boot-starter</artifactId> </dependency> 对于 Gradle 来说，需要在 build.gradle 添加如下依赖： https://springdoc.cn/elasticsearch-quarkus-connect/ Tue, 20 Aug 2024 18:52:39 +0800 https://springdoc.cn/elasticsearch-quarkus-connect/ 1、概览 Quarkus 是一个现代框架，它能让你轻松高效地地构建高性能应用。 本文将带你了解如何在 Quarkus 中整合 Elasticsearch，一个著名的全文搜索引擎和 NoSQL 数据库。 2、依赖和配置 首先，你需要在本地主机上运行 Elasticsearch 实例（推荐用 Docker 的方式）。 然后，在 Quarkus 应用中添加依赖： <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-elasticsearch-rest-client</artifactId> <version>${quarkus.version}</version> </dependency> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-elasticsearch-java-client</artifactId> <version>${quarkus.version}</version> </dependency> quarkus-elasticsearch-rest-client 依赖提供了底层的 Elasticsearch REST 客户端。 quarkus-elasticsearch-java-client 依赖提供了高级的 Elasticsearch Java 客户端。 在我们的应用中，可以根据需要选择使用合适的客户端。 接下来，将 Elasticsearch HOST 添加到 application.properties 文件中： quarkus.elasticsearch.hosts=localhost:9200 现在，我们可以开始在 Quarkus 应用中使用 Elasticsearch 了。ElasticsearchRestClientProducer 和 ElasticsearchJavaClientProducer 会自动创建所有必要的 Bean。 3、Elasticsearch 低级 REST 客户端 我们可以使用 Elasticsearch 低级 REST 客户端 将应用与 Elasticsearch 集成。这使得我们可以完全控制序列化和反序列化过程，并允许我们使用 JSON 构建 Elasticsearch 的查询。 https://springdoc.cn/java-email-sendgrid/ Sat, 17 Aug 2024 11:13:03 +0800 https://springdoc.cn/java-email-sendgrid/ 1、概览 无论是用户注册、密码重置还是促销活动，发送电子邮件都是现代 Web 应用的一项重要功能。 本文将带你了解如何在 Spring Boot 应用中使用 SendGrid 发送电子邮件。 2、SendGrid 设置 在开始之前，我们首先需要一个 SendGrid 账户。SendGrid 提供了免费套餐，允许我们每天发送多达 100 封电子邮件，这对于演示来说已经足够了。 注册完成后，需要创建一个 API Key 来对我们发送到 SendGrid 服务的请求进行 身份认证。 3、项目设置 在开始使用 SendGrid 发送电子邮件之前，需要添加 SDK 依赖并配置应用。 3.1、依赖 首先，在项目的 pom.xml 文件中添加 SendGrid SDK 依赖： <dependency> <groupId>com.sendgrid</groupId> <artifactId>sendgrid-java</artifactId> <version>4.10.2</version> </dependency> 该依赖为我们提供了与 SendGrid 服务交互和从应用发送电子邮件所需的类。 3.2、定义 SendGrid 配置属性 现在，为了与 SendGrid 服务交互并向用户发送电子邮件，我们需要配置 API Key 以验证 API 请求。我们还需要配置发件人姓名和电子邮件地址，它们应与我们在 SendGrid 账户中设置的发件人身份相匹配。 我们在项目的 application.yaml 文件中配置这些属性，并使用 @ConfigurationProperties 将这些值映射到 POJO，Service 层在与 SendGrid 交互时会引用配置的 POJO： @Validated @ConfigurationProperties(prefix = "com. https://springdoc.cn/hibernate-sequence-naming-strategies/ Fri, 16 Aug 2024 21:03:35 +0800 https://springdoc.cn/hibernate-sequence-naming-strategies/ 1、简介 本文将带你了解如何为数据库序列（Sequences）配置 Hibernate 6 的隐式 命名策略。Hibernate 6 引入了几种新的命名策略，这些策略会影响序列的命名和使用方式。 2、标准命名策略 默认情况下，Hibernate 6 使用标准命名策略。它根据实体名称和列名称生成序列名称。假如，我们有一个带有 id 列的实体 Person，那么序列名称就是 person_seq。 要修改命名策略，需要在 application.properties 中为不同的命名策略添加必要的配置。 # 使用标准命名策略 spring.jpa.properties.hibernate.id.db_structure_naming_strategy=standard 下面介绍如何为每种命名策略设置配置。 来看一个基本的 Person 实体类： @Entity public class Person { @Id @GeneratedValue(strategy = GenerationType.SEQUENCE) private Long id; private String name; // Getter / Setter 省略 } 在本例中，由于我们使用的是标准策略，因此在建表的同时，Hibernate 会自动生成一个名为 person_seq 的序列： Hibernate: create table person ( id bigint not null, name varchar(255), primary key (id) ) Hibernate: create sequence person_seq start with 1 increment by 50 标准策略的一个关键点是其默认增量（increment）值。Hibernate 会分配一个较大的值，如 50，以优化批处理操作，减少序列检索所需的数据库调用次数。 https://springdoc.cn/mybatis-plus-introduction/ Thu, 15 Aug 2024 10:18:56 +0800 https://springdoc.cn/mybatis-plus-introduction/ 1、简介 MyBatis 是一个流行的开源持久性框架，提供了 JDBC 和 Hibernate 的替代方案。 本文将带你了解 MyBatis 的一个扩展，名为 MyBatis-Plus，它具有许多方便的功能，可以大大地提高我们的开发效率。 2、MyBatis-Plus 整合 2.1、Maven 依赖 首先，在 pom.xml 中添加以下 Maven 依赖。 <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-spring-boot3-starter</artifactId> <version>3.5.7</version> </dependency> 最新版本的 Maven 依赖可在 此处 找到。由于这是基于 Spring Boot 3 的 Maven 依赖，我们还需要在 pom.xml 中添加 spring-boot-starter 依赖。 如果使用的是 Spring Boot 2，则需要添加以下依赖： <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.5.7</version> </dependency> 接着，在 pom.xml 中添加 H2 内存数据库依赖，用于验证 MyBatis-Plus 的特性和功能。 <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.3.230</version> </dependency> 同样，H2 的最新版本可以在 这里 找到。除了 H2 外，我们还可以使用 MySQL 等其他关系型数据库。 2.2、Client 依赖添加完毕后，创建 Client 实体，其中包含一些属性，如 id、firstName、lastName 和 email： https://springdoc.cn/spring-ai-embraces-openais-structured-outputs-enhancing-json-response/ Mon, 12 Aug 2024 10:29:01 +0800 https://springdoc.cn/spring-ai-embraces-openais-structured-outputs-enhancing-json-response/ OpenAI 最近 推出了 一项名为 “结构化输出”（Structured Outputs）的强大功能，可确保 AI 生成的响应严格遵守预定义的 JSON Schema。这一功能大大提高了 AI 生成的内容在实际应用中的可靠性和可用性。 Spring AI(1.0.0-SNAPSHOT) 已 完全集成 了对 OpenAI 的结构化输出的支持，以一种无缝的 Spring 原生方式为 Java 开发人员带来了这一功能。 下图显示了新的结构化输出功能如何扩展 OpenAI Chat API： 注：Spring AI 已经提供了 功能强大、与模型无关的结构化输出 工具，可用于包括 OpenAI 在内的各种 AI 模型。OpenAI 结构化输出功能提供了一个额外的、一致的、但针对特定模型的解决方案，目前仅适用于 gpt-4o、gpt-4o-mini 和更高版本的模型。 OpenAI 结构化输出功能可确保 AI 模型生成的响应符合所提供的 JSON Schema。这解决了 AI 驱动的应用程序中的几个常见难题： 类型安全：不再担心缺少必填 KEY 或枚举值无效； 明确拒绝：基于安全性的模型拒绝变得可以通过编程检测到； 简化的提示：实现一致的格式化，而无需使用过于具体的 Prompt（提示）。 Spring AI 允许开发人员以最少的配置利用这一功能。接下来看看如何在 Spring 应用中使用它。 编程式配置 你可以使用 OpenAiChatOptions Builder 以编程式设置响应格式，如下所示： String jsonSchema = """ { "type": "object", "properties": { "steps": { "type": "array", "items": { "type": "object", "properties": { "explanation": { "type": "string" }, "output": { "type": "string" } }, "required": ["explanation", "output"], "additionalProperties": false } }, "final_answer": { "type": "string" } }, "required": ["steps", "final_answer"], "additionalProperties": false } """; Prompt prompt = new Prompt("how can I solve 8x + 7 = -23", OpenAiChatOptions. https://springdoc.cn/java-enum-http-status/ Mon, 12 Aug 2024 09:59:22 +0800 https://springdoc.cn/java-enum-http-status/ 1、简介 Enum（枚举）提供了一种在 Java 编程语言中定义一组命名常量的强大方法。这些常量可用于表示相关值的固定集合，例如 HTTP 状态码。总所周知，互联网上的所有 Web 服务器都会响应 HTTP 状态码作为标准响应码。 本文将带你了解如何创建一个包含所有 HTTP 状态码的 Java 枚举。 2、了解 HTTP 状态码 HTTP 状态码在 Wweb 通信中起着至关重要的作用，它能告知客户端其请求的结果。这些代码分为五类，每一类在 HTTP 协议中都有特定的功能。 3、HTTP 状态码使用枚举的好处 在 Java 中枚举 HTTP 状态码有几个优点，包括： 类型安全：使用 Enum 枚举可确保类型安全，使代码更具可读性和可维护性 分组常量：Enum 枚举将相关常量组合在一起，以清晰和结构化的方式处理固定值集合 避免硬编码：将 HTTP 状态码定义为枚举，有助于防止硬编码字符串或整数造成的错误 增强清晰度和可维护性：这种方法通过增强清晰度、减少错误和提高代码的可维护性，促进软件开发的最佳实践 4、基本做法 为了在 Java 应用中有效管理 HTTP 状态码，我们可以定义一个枚举来封装所有标准 HTTP 状态码及其描述。 这种方法可以让我们充分利用枚举类型安全和代码清晰的优势。 定义 HttpStatus 枚举： public enum HttpStatus { CONTINUE(100, "Continue"), SWITCHING_PROTOCOLS(101, "Switching Protocols"), OK(200, "OK"), CREATED(201, "Created"), ACCEPTED(202, "Accepted"), MULTIPLE_CHOICES(300, "Multiple Choices"), MOVED_PERMANENTLY(301, "Moved Permanently"), FOUND(302, "Found"), BAD_REQUEST(400, "Bad Request"), UNAUTHORIZED(401, "Unauthorized"), FORBIDDEN(403, "Forbidden"), NOT_FOUND(404, "Not Found"), INTERNAL_SERVER_ERROR(500, "Internal Server Error"), NOT_IMPLEMENTED(501, "Not Implemented"), BAD_GATEWAY(502, "Bad Gateway"), UNKNOWN(-1, "Unknown Status"); private final int code; private final String description; HttpStatus(int code, String description) { this. https://springdoc.cn/spring-security-remove-role_prefix/ Fri, 09 Aug 2024 11:53:55 +0800 https://springdoc.cn/spring-security-remove-role_prefix/ 1、概览 在配置应用的安全设置时，用户的详细信息可能未包括 Spring Security 预期的 ROLE_ 前缀。这种情况下会导致 “Forbidden” 授权错误，无法访问受保护端点。 本文将带你了解如何配置 Spring Security，以允许使用不带 ROLE_ 前缀的角色。 2、Spring Security 默认行为 首先来看看 Spring Security 角色检查机制的默认行为。 添加一个 InMemoryUserDetailsManager，其中包含一个具有 ADMIN 角色的用户： @Configuration public class UserDetailsConfig { @Bean public InMemoryUserDetailsManager userDetailsService() { UserDetails admin = User.withUsername("admin") .password(encoder().encode("password")) .authorities(singletonList(new SimpleGrantedAuthority("ADMIN"))) .build(); return new InMemoryUserDetailsManager(admin); } @Bean public PasswordEncoder encoder() { return new BCryptPasswordEncoder(); } } 如上，创建 UserDetailsConfig 配置类，该类配置了一个 InMemoryUserDetailsManager Bean。在工厂方法内部，使用 PasswordEncoder 来处理用户详细信息的密码。 接着，添加要调用的端点： @RestController public class TestSecuredController { @GetMapping("/test-resource") public ResponseEntity<String> testAdmin() { return ResponseEntity. https://springdoc.cn/java-class-cast-operator-difference/ Fri, 09 Aug 2024 11:16:36 +0800 https://springdoc.cn/java-class-cast-operator-difference/ 1、简介 Java 中的转换（“Cast”）是一个基本概念，它允许将一种数据类型转换为另一种数据类型。它是在程序中有效操作对象和变量的关键过程。在现实世界中，“Cast” 类似于将一种单位的度量值转换为另一种单位的度量值，例如将英寸转换为厘米。 在 Java 的多态（Polymorphism）中，当超类引用子类的对象时，经常会使用到转换。例如，我们需要访问子类的特定方法或属性，就需要依靠转换来实现。这一点非常重要，因为 Java 是一种强类型语言，变量具有特定的数据类型。 本文将带你了解 Java Class.cast() 方法和 Cast（强转）操作符两个选项用法和差别，以及每个选项的最佳实践。 2、定义用例 以一个视频游戏角色的层次结构为例。 创建一个包含了超类 Character（角色）和子类 Warrior（战士）、Commander（指挥官）的示例。 该用例涉及创建 Warrior 和 Commander 的实例。这些实例存储在 Character 对象类型的集合中。之后，它们会被检索并转换回各自的特定类型。这种转换允许调用特定子类的方法。 3、定义 Model 类 首先，定义第一个继承自 Character 的子类，即实现了 obeyCommand() 方法的 Warrior： public class Warrior extends Character { public void obeyCommand(String command) { logger.info("Warrior {} obeys a command {}", this.getName(), command); } } 然后，创建 Character 的第二个子类，即 Commander。这个子类实现了一个 issueCommand() 方法，可以向战士们发布命令： public class Commander extends Character { public void issueCommand(String command) { log. https://springdoc.cn/java-best-practices-jdbc-connection-pool/ Fri, 09 Aug 2024 10:17:20 +0800 https://springdoc.cn/java-best-practices-jdbc-connection-pool/ 1、简介 本文将带你了解调整 JDBC 连接池大小的最佳策略。 2、什么是 JDBC 连接池，为什么要使用它？ JDBC 连接池是一种用于有效管理数据库连接的机制。创建数据库连接需要几个耗时的步骤，如 打开数据库连接 验证用户身份 创建用于通信的 TCP Sokcet 套接字 通过套接字收发数据 关闭连接和 TCP Sokcet 套接字 为每个用户请求重复这些步骤的效率可能会很低，尤其是对于有许多用户的应用。JDBC 连接池通过提前创建一个可重复使用的连接池来解决这个问题。当应用程序启动时，它会在池中创建并维护数据库连接。池连接管理器负责管理这些连接并处理其生命周期。 当客户端请求连接时，连接池管理器会从连接池中提供一个连接，而不是创建一个新的连接。一旦客户端完成操作，连接就会返回池中重复使用，而不是关闭。这种连接的重复使用节省了时间和资源，大大提高了应用程序的性能。 3、为什么 JDBC 连接池的大小对应用来说很重要？ 确定 JDBC 连接池的最佳大小对于平衡性能和资源利用率至关重要。较小的连接池可能会加快连接访问速度，但如果没有足够的连接来满足所有请求，则可能导致延迟。相反，较大的连接池可确保有更多连接可用，减少在队列中花费的时间，但可能会降低连接表的访问速度。 “连接表” 通常指的是管理和跟踪数据库连接的内部数据结构。它记录了当前连接的状态（如空闲、使用中等）以及相关的元数据，以便有效地分配和管理连接。这个“表”并不是数据库中的实际表，而是连接池实现中的一个逻辑概念。 下表总结了在确定连接池大小时需要考虑的利弊： 连接池大小 优点 缺点 较小的连接池 更快地访问连接表 可能需要更多连接来满足请求。请求在队列中停留的时间可能会更长 较大的连接池 有更多连接来满足请求。请求在队列中花费的时间减少（或没有） 降低访问连接表的速度 4、确定 JDBC 连接池大小时应考虑的要点 在确定池大小时，需要考虑几个因素。首先，应该评估平均事务响应时间和花费在数据库查询上的时间。负载测试可以帮助确定这些时间，建议在计算连接池大小时再增加 25% 的容量，以应对意外负载。其次，连接池应能根据实际需要进行增减。我们可以使用日志或 JMX 监视来监控系统，从而动态调整池的大小。 此外，还应考虑每次页面加载执行多少次查询以及每次查询的持续时间。为了获得最佳性能，我们可以从少量连接开始，然后逐渐增加。每个节点 8 到 16 个连接的池通常是最佳的。我们还可以根据监控统计数据调整空闲超时（Idle Timeout）和池大小调整数量（Pool Resize Quantity）值。 5、JDBC 连接池的基本控制设置 这些基本设置可控制池的大小： 连接池属性 说明 初始和最少连接数 池创建时的大小及其允许的最小连接数量 池最大连接数 连接池可维护的最大连接数量 池大小调整数量 空闲超时时要移除的连接数。闲置时间超过超时的连接将被移除，一旦连接池达到初始和最小连接池大小，就会停止移除。 最大空闲连接数 池中允许的最大闲置连接数。如果闲置连接数超过此限制，多余的连接将被关闭，从而释放资源 最小空闲连接数 在连接池中保留的空闲连接的最小数量 最大等待时间 应用等待连接可用的最长时间 验证查询 用于验证连接的 SQL 查询，然后再将其交给应用 6、调整 JDBC 连接池大小的最佳实践 以下是调整 JDBC 连接池以确保与数据库实例之间健康连接的一些最佳实践。 https://springdoc.cn/spring-boot-return-errors-problemdetail/ Wed, 07 Aug 2024 11:08:20 +0800 https://springdoc.cn/spring-boot-return-errors-problemdetail/ 1、简介 本文将带你了解如何在 Spring Boot 应用中使用 ProblemDetail 响应错误信息，无论我们处理的是 REST API 还是 Reactive Stream（响应式流），它都提供了一种向客户端传达错误的标准化方式。 2、为什么要关注 ProblemDetail？ 使用 ProblemDetail 来标准化错误响应对任何 API 都至关重要。 它可以帮助客户理解和处理错误，提高 API 的可用性和可调试性。这将带来更好的开发体验和更强大的应用。 采用它还有助于提供更翔实的错误信息，这对维护我们的服务和排除故障至关重要。 3、传统的错误处理方式 在 ProblemDetail 之前，我们经常在 Spring Boot 中实现自定义 ExceptionHandler 和 ResponseEntity 来处理错误。我们会创建自定义的错误响应结构。这导致了不同 API 之间的不一致性。 这种方式不仅需要大量的模板代码。而且，缺乏表示错误的标准化方式，因此客户端很难统一解析和理解错误信息。 4、ProblemDetail 规范 ProblemDetail 规范是 RFC 7807 标准的一部分。它为错误响应定义了一致的结构，包括诸如类型（type）、标题（title）、状态（status）、详情（detail）和实例（instance）等字段。这种标准化提供了一个通用的错误信息格式，有助于 API 开发人员和使用者。 实现 ProblemDetail 可确保我们的错误响应具有可预测性并易于理解。这反过来提高了我们的 API 和其客户端之间的整体沟通效果。 5、在 Spring Boot 中实现 ProblemDetail 在 Spring Boot 中有多种方法可以实现 ProblemDetail。 5.1、通过配置属性启用 ProblemDetail 我们可以添加一个配置属性来启用它。对于 RESTful 服务，在 application.properties 中添加以下属性： spring.mvc.problemdetails.enabled=true 此属性可使 ProblemDetail 自动用于基于 MVC（servlet 栈）的应用中的错误处理。 https://springdoc.cn/java-21-improved-emoji-support/ Wed, 07 Aug 2024 10:27:39 +0800 https://springdoc.cn/java-21-improved-emoji-support/ 1、概览 Java 21 在 java.lang.Character 类中引入了一组新方法，为 Emoji 表情符号提供更好的支持。通过这些方法，我们可以轻松检查某个字符是否是 Emoji 表情符号，并检查 Emoji 表情符号的属性和特征。 本文将带你了解这些新添加的方法，以及与 Java 21 中 Emoji 表情符号处理相关的关键概念。 2、Character API 的更新 Java 21 在 java.lang.Character 类中引入了六个与 Emoji 表情符号处理相关的新方法。所有新方法都是静态的，以代表字符 Unicode 码点的 int 作为参数，并返回 boolean 值。 Unicode 码点是分配给 Unicode 标准中每个字符的唯一数值。它代表不同平台和语言中的特定字符。例如，码点 U+0041 代表字母 A，十六进制形式为 0x0041。 现在，让我们来仔细看看这些与 Emoji 表情符号相关的新方法。 2.1、isEmoji() isEmoji(int codePoint) 方法是新 emoji 方法中最基本的方法。它接收代表字符 Unicode 码点的 int 值，并返回一个 boolean 值，表示该字符是否为 Emoji。 用法如下； String messageWithEmoji = "Hello Java 21! 😄"; String messageWithoutEmoji = "Hello Java! https://springdoc.cn/java-spring-mockbeans/ Wed, 07 Aug 2024 10:06:28 +0800 https://springdoc.cn/java-spring-mockbeans/ 1、概览 本文将带你了解 Spring Boot @MockBeans 注解的用法。 2、示例项目 以一个简单的票据验证器（Ticket Validator）示例为例： public class TicketValidator { private CustomerRepository customerRepository; private TicketRepository ticketRepository; public boolean validate(Long customerId, String code) { customerRepository.findById(customerId) .orElseThrow(() -> new RuntimeException("Customer not found")); ticketRepository.findByCode(code) .orElseThrow(() -> new RuntimeException("Ticket with given code not found")); return true; } } 如上，我们定义了 validate() 方法，用于检查数据库中是否存在给定数据。它依赖 CustomerRepository 和 TicketRepository。 现在，来看看如何使用 Spring 的 @MockBean 和 @MockBeans 注解创建测试和模拟依赖。 3、@MockBean 注解 Spring 框架提供了 @MockBean 注解，用于模拟依赖以进行测试。该注解允许我们定义特定 Bean 的模拟版本。新创建的模拟 Bean 将被添加到 Spring ApplicationContext 中。因此，如果已经存在相同类型的 Bean，它将被替换为模拟版本。 https://springdoc.cn/spring-boot-config-binary-data-in-yaml/ Thu, 01 Aug 2024 11:32:08 +0800 https://springdoc.cn/spring-boot-config-binary-data-in-yaml/ Spring Boot 中的 application.yaml / application.properties 配置文件用于定义应用运行时需要的配置属性。 Spring Boot 提供了强大的配置属性绑定功能，可以把配置文件中的属性绑定到 Java Bean，并且会根据 Java Bean 的字段类型对配置属性进行必要的转换。 绑定属性到 Bean 通过一个简单的示例来看看如何把配置文件中的配置属性绑定到 Bean，并且自动转换其类型。 本文使用的 Spring Boot 版本是 3.3.1。 创建 Spring Boot 项目 创建任意 Spring Boot 应用。 定义配置属性 在 src/main/resources 目录下创建 application.yaml 配置文件，并在其中定义如下自定义的配置属性： app: # 数值 port: 8080 # 字符串 title: "Spring Boot 属性绑定测试" # Duration duration: 15s # DataSize data-size: 10MB # 集合 file-types: ["png", "jpeg"] 如上，在配置文件中定义了几个不同类型的配置属性。在本例中，这些配置属性的名称没有任何意义，随意取的。 定义配置 Bean 在 cn.springdoc.demo.prop 包下定义与配置文件中属性相对应的 Bean。 package cn. https://springdoc.cn/spring-ai-with-groq-a-blazingly-fast-ai-inference-engine/ Thu, 01 Aug 2024 10:37:45 +0800 https://springdoc.cn/spring-ai-with-groq-a-blazingly-fast-ai-inference-engine/ 更快的信息处理速度不仅能提供信息，还能改变我们的认知和创新方式。 Spring AI 是一个强大的框架，用于将 AI 能力集成到 Spring 应用中，现在已支持 Groq - 一个运行速度极快的 AI 推理引擎，并支持工具/函数调用。 利用 Groq 的 OpenAI 兼容 API，Spring AI 通过调整其现有的 OpenAI Chat 客户端实现了无缝集成。这种方法使开发人员能够通过熟悉的 Spring AI API 利用 Groq 的高性能模型。 本文将带你了解如何配置和使用 Spring AI OpenAI 聊天客户端与 Groq 进行连接。详细信息请查阅 Spring AI Groq 文档 和相关 测试。 Groq API Key 要与 Groq 交互，你需要从 https://console.groq.com/keys 获取 Groq API Key。 依赖 将 Spring AI OpenAI Starter 添加到项目中。 <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-openai-spring-boot-starter</artifactId> </dependency> 对于 Gradle，在 build.gradle 中添加以下内容： https://springdoc.cn/jpa-could-not-determine-recommended-jdbctype-for-class/ Thu, 01 Aug 2024 10:08:16 +0800 https://springdoc.cn/jpa-could-not-determine-recommended-jdbctype-for-class/ 1、简介 本文将带你了解使用 Hibernate 时出现 “could not determine recommended JdbcType for class” 异常的原因，以及解决办法。 2、常见原因 出现该异常，通常是因为 JPA（Java Persistence API）抛出了异常。 这种情况发生在 JPA 无法确定类的推荐 JDBC 类型时。 通常，这会 Hibernate 应用启动期间发生，当 Hibernate 尝试创建数据库 Schema 或验证映射时。 3、复合数据类型 JPA 中出现 “could not determine recommended JdbcType for class” 错误的一个常见原因是，我们在实体类中使用了复合数据类型或其他非原始类型。一个典型的例子就是使用 java.util.Map 来存储动态键值对。 来看看下面这个实体类： @Entity public class Student { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; // 使用了 Map private Map<String, String> studentDetails; // Getter/Setter 省略 } 在上例中，studentDetails 字段是 Map<String, String>。JPA 可能会抛出错误，因为它无法自动为这种复杂的数据类型确定推荐的 JDBC 类型。 https://springdoc.cn/spring-5-get-bean-by-supplier/ Wed, 31 Jul 2024 10:46:11 +0800 https://springdoc.cn/spring-5-get-bean-by-supplier/ 今天遇到了一个面试题：Spring 中 Bean 的实例化有哪些方式？ 大家知道，Spring 中 Bean 的配置方式有很多种，但是正常来说，无论你是 XML 文件配置，还是用类似 @Service 注解这种配置，本质上最终都是通过反射去完成 Bean 的初始化的；@Bean 注解则稍微特殊一点，往往我们在 @Bean 注解中是自己 new 出来目标 Bean，但是 @Bean 注解所标记的方法也是通过反射调用的。 似乎 Bean 的实例化离不开反射。 那么除了上面这些方案，还有没有其他方案呢？本文和大家探讨一下这个问题。 以下内容基于 Spring6.0.4。 总所周知，当使用 Spring 容器的时候，如果遇到一些特殊的 Bean，一般来说可以通过如下三种方式进行配置： 静态工厂方法 实例工厂方法 FactoryBean 不过从 Spring5 开始，在 AbstractBeandefinition 类中多了一个属性，对于特殊的 Bean 我们有了更多的选择： /** * Specify a callback for creating an instance of the bean, * as an alternative to a declaratively specified factory method. * <p>If such a callback is set, it will override any other constructor * or factory method metadata. https://springdoc.cn/java-lombok-extensionmethod/ Wed, 31 Jul 2024 09:59:52 +0800 https://springdoc.cn/java-lombok-extensionmethod/ 1、概览 Lombok 是一个流行的 Java 库，它通过减少模板代码来简化代码编写。其强大功能之一是 @ExtensionMethod 注解，可以增强代码的可读性和简洁性。 本文将带你了解 Lombok 中的 @ExtensionMethod 注解有什么用，以及如何有效地使用它。 2、@ExtensionMethod 是什么？ @ExtensionMethod 注解允许为现有类添加静态方法扩展。这意味着可以在原始类中调用在其他类中定义的方法。这有利于在不修改源代码的情况下增强第三方库或现有类的功能。 3、@ExtensionMethod 的原理 要使用 @ExtensionMethod，需要用 @ExtensionMethod 来注解一个类，并指定包含想要扩展的静态方法的类。然后，Lombok 会生成必要的代码，使这些方法可用，就好像它们是注解类的方法一样。 假设我们有一个工具类 StringUtils，其中的 reverse() 方法可以反转字符串。我们想把这个方法当作 String 类的一个方法来使用。Lombok 的 @ExtensionMethod 可以帮助我们实现这一目的。 首先，需要在项目中添加 Lombok 依赖。如果使用 Maven，可以在 pom.xml 中添加以下内容： <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.24</version> <scope>provided</scope> </dependency> Lombok 的最新版本可以在 Maven 中央仓库 找到。 3.1、String 示例 先创建 StringUtils 工具类，实现 reverse 方法： public static String reverse(String str) { return new StringBuilder(str).reverse().toString(); } 接下来，创建一个使用 @ExtensionMethod 注解的测试类： @ExtensionMethod(StringUtils.class) public class StringUtilsUnitTest { @Test public void givenString_whenUsingExtensionMethod_thenReverseString() { String original = "Lombok Extension Method"; String reversed = original. https://springdoc.cn/java-valid-annotation-child-objects/ Mon, 29 Jul 2024 11:13:35 +0800 https://springdoc.cn/java-valid-annotation-child-objects/ 1、简介 本文将带你了解如何使用 @Valid 注解来验证对象及其嵌套的子对象。 当传入数据是基本数据类型，比如 Integer 或 String 时，验证数据可以很简单。然而，当传入信息是一个对象，特别是一个对象图时，验证可能会更加困难。幸运的是，@Valid 注解简化了对嵌套子对象的验证。 2、@Valid 注解是啥 @Valid 注解来自 Jakarta Bean Validation 规范，用于标记需要验证的特定参数。 使用该注解可确保传递给方法或存储在字段中的数据符合指定的验证规则。这有助于提高数据的完整性和一致性。 当在 JavaBean 的字段或方法上使用时，它会触发所有已定义的约束检查。Bean Validation API 中最常用的一些约束包括 @NotNull、@NotBlank、@NotEmpty、@Size、@Email、@Pattern 等。 3、在子对象上使用 @Valid 注解 首先，必须确定验证规则，并对字段应用前面提到的验证约束。 接下来，定义一个 Project 类，该类包含一个嵌套的 User 对象，并用 @Valid 注解来装饰该对象： public class Project { @NotBlank(message = "Project title must be present") @Size(min = 3, max = 20, message = "Project title size not valid") private String title; @Valid // 校验嵌套的对象 private User owner; // 构造函数、Getter、Setter 方法省略 } public class User { // 校验规则 @NotBlank(message = "User name must be present") @Size(min = 3, max = 50, message = "User name size not valid") private String name; // 校验规则 @NotBlank(message = "User email must be present") @Email(message = "User email format is incorrect") private String email; // 构造函数、Getter、Setter 方法省略 } 之后，通过 Validator 实例的 validate() 方法来验证对象： https://springdoc.cn/spring-ai-with-ollama-tool-support/ Fri, 26 Jul 2024 22:22:11 +0800 https://springdoc.cn/spring-ai-with-ollama-tool-support/ 本周早些时候，Ollama 推出 了一项令人兴奋的新功能：对大型语言模型（LLM）的工具支持。 今天，我们非常高兴地宣布 Spring AI（1.0.0-SNAPSHOT）已完全支持这一强大功能，将 Ollama 的函数调用功能引入 Spring 生态系统。 Ollama 的工具支持允许模型决定何时调用外部函数以及如何使用返回的数据。这为访问实时信息到执行复杂计算等各种可能性打开了大门。Spring AI 采用了这一概念，并将其与 Spring 生态系统无缝集成，使 Java 开发人员能够非常轻松地在其应用程序中利用这一功能。Spring AI 的 Ollama 函数调用支持的主要功能包括： 轻松集成：将 Java 函数注册为 Spring Bean，并与 Ollama 模型一起使用。 灵活配置：多种注册和配置函数的方法。 支持多种函数：在一个聊天会话中注册和使用多种函数。 运行时函数选择：动态选择为每个提示（Prompt）启用哪些函数。 代码可移植性：使用不同的 LLM 提供商（如 OpenAI、Mistral、VertexAI、Anthropic、Groq），无需修改代码即可重复使用你的应用代码。 工作原理 定义自定义 Java 函数并将其注册到 Spring AI。 执行可能需要调用函数才能完成回答的聊天请求。 当 AI 模型确定需要调用一个函数时，它会生成一个包含函数名称和参数的 JSON 对象。 Spring AI 会拦截该请求，调用你的 Java 函数，并将结果返回给模型。 该模型将函数的输出纳入其响应中。 入门 先决条件 首先需要在本地计算机上运行 Ollama（0.2.8 以上）。请参阅官方的 Ollama 项目 README，开始在本地计算机上运行模型。然后调出支持模型的工具，例如 Llama 3.1、Mistral、Firefunction v2、Command-R +。。。支持的模型列表可在 模型页面的工具类别 下找到。 ollama pull mistral 依赖 要开始在 Spring AI 中使用 Ollama 函数调用，请在项目中添加以下依赖： https://springdoc.cn/spring-postconstruct-predestroy/ Thu, 25 Jul 2024 11:37:32 +0800 https://springdoc.cn/spring-postconstruct-predestroy/ 1、简介 Spring 允许我们在 Bean 的创建和销毁时执行自定义操作。例如，可以让 Bean 实现 InitializingBean 和 DisposableBean 接口，从而在创建和销毁时触发回调方法。 本文将带你了解第二种实现方式，即使用 @PostConstruct 和 @PreDestroy 注解。 2、@PostConstruct Spring 只会在 Bean 属性初始化后调用一次注解了 @PostConstruct 的方法。即使没有任何属性需要初始化，这些方法也会运行。 使用 @PostConstruct 注解的方法可以用任何访问级别，但不能是静态的。 @PostConstruct 一个可能的用途是填充数据。例如，在开发过程中，我们想创建一些默认用户： @Component public class DbInit { @Autowired private UserRepository userRepository; @PostConstruct private void postConstruct() { // 初始化默认用户 User admin = new User("admin", "admin password"); User normalUser = new User("user", "user password"); userRepository.save(admin, normalUser); } } 上述示例将首先初始化 UserRepository 属性，然后运行 @PostConstruct 方法。 3、@PreDestroy 在 Spring 将 Bean 从 Application Context 中删除之前，会运行一次注解了 @PreDestroy 的方法。 https://springdoc.cn/thread-pool-java-and-guava/ Thu, 25 Jul 2024 10:10:30 +0800 https://springdoc.cn/thread-pool-java-and-guava/ 1、概览 本文将带你了解 Java 中的线程池。首先介绍 Java 中的标准库，然后介绍 Google 的 Guava 库。 2、线程池 在 Java 中，线程被映射到系统级线程，而系统级线程是操作系统的资源。如果不加控制地创建线程，这些资源可能很快就会耗尽。 操作系统也会在线程之间进行上下文切换，以模拟并行处理。一个简单的观点是，创建的线程越多，每个线程实际工作的时间就越少。 线程池模式有助于在多线程应用中节省资源，并将并行性控制在某些预定义的范围内。 使用线程池时，我们将并发代码编写为并行任务的形式，并将它们提交给线程池实例执行。这个实例控制着多个可重复使用的线程来执行这些任务。 该模式允许我们控制应用创建的线程数量及其生命周期。还能调度任务的执行，并将接收到的任务保存在队列中。 3、Java 中的线程池 3.1、Executors、Executor 和 ExecutorService Executors 工具类包含多个用于创建预配置线程池实例的方法。这些类是一个很好的起点。如果不需要进行任何自定义微调，就可以使用它们。 在 Java 中，我们使用 Executor 和 ExecutorService 接口来处理不同的线程池实现。通常，应该使代码与线程池的实际实现解耦，并在整个应用中使用这些接口。 3.1.1、Executor Executor 接口有一个 execute 方法，用于提交实现了 Runnable 接口的实例以供执行。 来看一个快速示例，演示如何使用 Executors API 获取由单线程池和无界队列支持的 Executor 实例，以便按顺序执行任务。 如下，运行一个任务，只需在屏幕上打印 “Hello World” 即可。我们以 lambda（Java 8 的一个特性）的形式提交任务，它被推断为 Runnable： Executor executor = Executors.newSingleThreadExecutor(); executor.execute(() -> System.out.println("Hello World")); 3.1.2、ExecutorService ExecutorService 接口包含大量用于控制任务进度和管理服务终止的方法。使用该接口，我们可以提交任务以供执行，还可以使用返回的 Future 实例控制任务的执行。 现在，创建一个 ExecutorService，提交一项任务，然后使用返回的 Future 的 get 方法等待提交的任务完成并返回结果值： https://springdoc.cn/spring-boot-h2-exception-schema-not-found/ Tue, 23 Jul 2024 11:11:57 +0800 https://springdoc.cn/spring-boot-h2-exception-schema-not-found/ 1、概览 H2 是一个开源的 SQL 数据库，在 Java 中通常用于测试。它是一个内存数据库，不会将任何数据持久化到磁盘，因此速度非常快。 在与 Spring Boot 整合时，我们可能会遇到 “Schema not found” 异常，本文将带你了解出现此异常的原因，以及如何解决该异常。 2、理解异常的原因 H2 的默认 Schema 是 PUBLIC。如果我们映射的 JPA 实体类不使用 PUBLIC Schema，则必须确保在 H2 上创建了 Schema。当目标 Schema 不存在时，Spring Boot 会抛出异常 “Schema not found”。 模拟一下这个场景。在 Spring Boot 应用中创建以下实体类和 Repository。 @Entity @Table(name = "student", schema = "test") public class Student { @Id @Column(name = "student_id", length = 10) private String studentId; @Column(name = "name", length = 100) private String name; // 构造函数、Getter\Setter 方法 } 如上 @Table 注解指定了实体映射到 test Schema 下的 student 表的映射细节。 https://springdoc.cn/spring-data-mongo-several-criteria/ Tue, 23 Jul 2024 10:03:47 +0800 https://springdoc.cn/spring-data-mongo-several-criteria/ 1、简介 本文将带你了解如何使用 Spring Data JPA 在 MongoDB 中创建具有多个 Criteria（条件）的查询。 2、项目设置 首先，在 pom.xml 文件中添加 Spring Data MongoDB Starter 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> <version>3.3.1</version> </dependency> 通过该依赖，我们可以在 Spring Boot 项目中使用 Spring Data MongoDB 的功能。 2.1、定义 MongoDB Document 和 Repository 接下来，定义一个 MongoDB Document（文档），它是一个用 @Document 注解的 Java 类。该类映射到 MongoDB 中的一个 Collection（集合）。 例如，创建一个 Product Document： @Document(collection = "products") public class Product { @Id private String id; private String name; private String category; private double price; private boolean available; // Getter 和 Setter 方法 } 在 Spring Data MongoDB 中，我们可以创建 Repository 来定义自己的查询方法。通过注入 MongoTemplate，可以对 MongoDB 数据库执行高级操作。该类为执行查询、聚合数据和有效处理 CRUD 操作提供了丰富的方法集： https://springdoc.cn/spring-boot-3-3-2-available-now/ Fri, 19 Jul 2024 11:39:35 +0800 https://springdoc.cn/spring-boot-3-3-2-available-now/ Spring Boot v3.3.2 正式发布。 🐞 Bug 修复 没有在 Spring Integration 6.2 中引入的 defaultTimeout 设置的配置属性 #41521 在 OnClassCondition.resolveOutcomesThreaded 中进行自动配置时出现 NPE，因为 firstHalf 为 null #41504 Spring 授权服务器现在将 multipleIssuersAllowed 默认为 false，并且不容易重新启用 #41355 ServiceConnection 无法与 @DataLdapTest 一起使用 #41325 PropertiesMigrationListener 错误地将属性报告为过时属性 #41252 @NestedConfigurationProperty 对 Record 不起作用 #41251 TestcontainersLifecycleBeanPostProcessor 无法与 Scope Bean 正常工作 #41238 如果 spring.config.import 无法解析，错误信息可能具有误导性 #41236 Docker desktop 更新后，构建镜像失败，提示 “Illegal char <:> at index 5: npipe:////” #41234 使用 Jetty 时，Filter、Listener 和 Servlet 未使用同一线程上下文 classloader 初始化 #41225 在 Webflux 中使用 DirtiesContext、随机端口和多个上下文的情况下，可能会导致多个上下文的行为异常 #41221 在原生镜像中使用 spring-boot-starter-activemq 时，org. https://springdoc.cn/database-auditing-jpa/ Fri, 19 Jul 2024 10:30:24 +0800 https://springdoc.cn/database-auditing-jpa/ 1、概览 就 ORM 而言，数据库审计指的是跟踪和记录与实体相关的事件，或者简单地说是实体版本管理。受 SQL 触发器的启发，这些事件是对实体的插入、更新和删除操作。数据库审计的好处类似于源代码版本控制。 本文将带你了解在应用中使用审计的三种方法。首先介绍来自于 JPA 标准的审计实现、然后再介绍由 Hibernate 和 Spring Data 分别提供的审计的扩展实现。 下面是本文中使用的相关实体 Bar 和 Foo 示例： 2、JPA 审计 JPA 并没有明确包含审计 API，但我们可以通过使用实体生命周期事件来实现这一功能。 2.1、@PrePersist、@PreUpdate 和 @PreRemove 在 JPA 实体类中，我们可以使用 @PrePersist、@PreUpdate 和 @PreRemove 注解指定一个方法作为回调，以在相应的 DML 操作前执行它。 @Entity public class Bar { @PrePersist public void onPrePersist() { ... } @PreUpdate public void onPreUpdate() { ... } @PreRemove public void onPreRemove() { ... } } 实体内部的回调方法应是非 static 的，返回类型为 void，且不带参数。访问权限任意。 注意，JPA 中的 @Version 注解与本文的主题没有关系，它是一种乐观锁，与审计数据无关。 https://springdoc.cn/spring-data-jpa-stream/ Fri, 19 Jul 2024 10:04:59 +0800 https://springdoc.cn/spring-data-jpa-stream/ 简介 本文将带你了解在 Spring Data JPA 中使用 Stream（流式）查询的最佳方式。 当需要获取较大的结果集时，使用 Java Stream 的好处是可以逐步迭代查询结果集，避免一次性获取所有数据可能导致的内存溢出异常。 JPA Stream 方法 自 2.2 版起，你可以使用 JPA 的 getResultStream 方法以 Stream 的形式处理结果集。 getResultStream 使用 JDBC ResultSet 对给定查询返回的记录进行流式处理。特别是在处理大结果集的时候，这种方法很有效率。 Spring Data JPA Stream 查询方法 如果要对查询结果集进行流式处理，则需要在 Spring Data JPA 查询方法中返回 Java Stream 类型，如下例所示： @Repository public interface PostRepository extends BaseJpaRepository<Post, Long> { @Query(""" select p from Post p where date(p.createdOn) >= :sinceDate """ ) @QueryHints( @QueryHint(name = AvailableHints.HINT_FETCH_SIZE, value = "25") ) // 返回 Stream Stream<Post> streamByCreatedOnSince(@Param("sinceDate") LocalDate sinceDate); } 对于 PostgreSQL 和 MySQL，指定 FETCH_SIZE JPA QueryHint 是必要的，它指示 JDBC 驱动每次迭代的时候最多预取 25 条记录。否则，PostgreSQL 和 MySQL JDBC 驱动会在遍历底层 ResultSet 之前预取所有查询结果。 https://springdoc.cn/spring-security-6-3/ Wed, 17 Jul 2024 11:07:01 +0800 https://springdoc.cn/spring-security-6-3/ 1、简介 Spring Security 6.3 版在框架中引入了一系列安全增强功能。本文将带你了解其中一些最值得注意的特性，重点介绍它们的优点和用法。 2、被动式的 JDK 序列化支持 Spring Security 6.3 包含被动式的 JDK 序列化支持（Passive JDK Serialization Support），首先先来了解一下相关的问题和困扰。 2.1、Spring Security 的序列化设计 在 6.3 版本之前，Spring Security 对其类在不同版本之间通过 JDK Serialization 进行序列化和反序列化有严格的策略。这个限制是框架的一个有意设计决策，旨在确保安全性和稳定性。其理由是防止使用不同版本的Spring Security 反序列化在一个版本中序列化的对象时出现不兼容性和安全漏洞。 这一设计的一个关键方面是在整个 Spring Security 项目中使用全局 serialVersionUID。在 Java 中，序列化和反序列化过程使用唯一标识符 serialVersionUID 来验证加载的类是否与序列化对象完全一致。 通过为 Spring Security 的每个发布版本维护一个唯一的全局 serialVersionUID，该框架可确保一个版本的序列化对象无法使用另一个版本进行反序列化。这种方法有效地创建了一个版本屏障，防止了序列化版本 serialVersionUID 值不匹配的对象被反序列化。 例如，Spring Security 中的 SecurityContextImpl 类表示 Security Context 信息。该类的序列化版本包含该版本特有的 serialVersionUID。当尝试在不同版本的 Spring Security 中反序列化该对象时，serialVersionUID 不匹配会阻止该过程成功进行。 2.2、序列化设计带来的困扰 在优先增强安全性的同时，这种设计策略也带来了一些困扰。开发人员通常将 Spring Security 与 Spring Session 等其他 Spring 库集成，以管理用户登录会话（Session）。这些会话包含重要的用户身份认证和 Security Context 信息，通常通过 Spring Security 类实现。此外，为了优化用户体验并提高应用的可扩展性，开发人员通常会在各种持久存储解决方案（包括数据库）中存储这些会话数据。 https://springdoc.cn/spring-validator-interface/ Wed, 17 Jul 2024 10:24:29 +0800 https://springdoc.cn/spring-validator-interface/ 1、概览 Spring Validator 接口为验证对象提供了一种灵活且可定制的方式。本文将带你了解如何在 Spring 应用中使用 Validator 接口验证对象。 2、Spring Validator 接口 Validator 接口是 Spring 框架的一部分，它提供了一种验证对象的方法。 这是一个简单的接口，定义了两个方法：supports() 和 validate()，用于确定 Validator 是否能验证对象并执行验证逻辑。 2.1、supports(Class clazz) 方法 Validator 接口中的 supports() 方法决定 Validator 能否验证特定类的实例。该方法的参数 Class<?> clazz 代表被验证对象的类。它是一个泛型类（Class<?>），可以灵活用于不同的对象类型。 具体来说，Spring 利用 isAssignableFrom() 方法来检查对象是否可以合法地转换为 Validator 支持类的对象。因此，如果 Validator 能处理所提供的 clazz 对象，它就会返回 true，否则就会返回 false，以表示应使用另一个 Validator。 @Override public boolean supports(Class<?> clazz) { return User.class.isAssignableFrom(clazz); } 在上例中，Validator 配置为仅支持验证类型为 User 或其子类的对象。isAssignableFrom() 方法通过继来承验证兼容性 - 对于 User 及其子类，它返回 true，对于任何其他类类型，它返回 false。 2.2、validate(Object target, Errors errors) 方法 validate() 方法则用于为 Validator 支持的对象定义自定义验证逻辑。 https://springdoc.cn/java-graphql-upload-file/ Tue, 16 Jul 2024 11:36:09 +0800 https://springdoc.cn/java-graphql-upload-file/ 1、简介 GraphQL 改变了开发人员与 API 交互的方式，为传统的 REST 方法提供了一个精简、强大的替代方案。 然而，在 Java 中使用 GraphQL 处理文件上传，特别是在 Spring Boot 应用中，由于 GraphQL 对二进制数据的处理方式，需要进行一些设置。本文将带你了解如何在 Spring Boot 应用中使用 GraphQL 上传文件。 2、GraphQL文件上传 与 HTTP 文件上传 在使用 Spring Boot 开发 GraphQL API 时，遵循最佳实践通常涉及利用标准的 HTTP 请求来处理文件上传。 通过专用的 HTTP 端点管理文件上传，然后通过 URL 或 ID 等标识符将这些上传链接到 GraphQL Mutation，开发人员可以有效地将直接嵌入 GraphQL Query 的文件上传的复杂性和处理开销降至最低。这种方法不仅简化了上传过程，还有助于避免与文件大小限制和序列化需求相关的潜在问题，从而有助于实现更加精简和可扩展的应用结构。 不过，在某些情况下，有必要将文件上传直接整合到 GraphQL 查询中。在这种情况下，需要进行一些特别的定制，在用户体验和应用程序性能之间取得平衡。因此，我们需要定义一种专门的量 Scalar Type 来处理上传。此外，这种方法还需要部署特定的机制来验证输入，并将上传的文件正确映射到 GraphQL 操作中的变量。此外，文件上传需要使用 Content Type 为 multipart/form-data 的请求体，因此需要实现一个自定义的 HttpHandler。 3、 在 GraphQL 中实现文件上传 首先，需要使用 Spring Boot 官方的 GraphQL Starter。 https://springdoc.cn/spring-manually-destroy-prototype-bean/ Tue, 16 Jul 2024 10:25:57 +0800 https://springdoc.cn/spring-manually-destroy-prototype-bean/ 1、简介 本文将带你了解 Spring 如何处理 Prototype Bean 并管理其生命周期，主要介绍是否有必要手动销毁 Prototype Bean、何时销毁以及如何销毁。 Spring 提供了多种 Bean Scope，本文主要聚焦 Prototype。 2、Prototype Bean 及其生命周期 Scope（作用域）确定了 Bean 在其存在的上下文中的生命周期和可见性。根据 Scope 的定义 ，IoC 容器负责管理 Bean 的生命周期。Prototype（原型）Scope 指示容器在每次使用 getBean() 请求或注入到另一个 Bean 时创建一个新的 Bean 实例。在创建和初始化方面，可以放心地依赖于 Spring。然而，销毁 Bean 的过程则不同。 在了解销毁 Bean 的必要性之前，先看看如何创建一个 Prototype Bean，如下： @Component // 指定 Bean 的 Scope 为 Prototype @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) public class PrototypeExample { } 3、Prototype Bean 需要手动销毁吗？ Spring 不会自动销毁 Prototype Bean。与 Singleton Scope 不同，IoC 容器并不负责 Prototype Bean 整个的生命周期。容器会实例化、配置和组装 Prototype Bean，但之后将停止跟踪其状态。 https://springdoc.cn/what-s-new-in-spring-framework-6-1-1-1/ Thu, 11 Jul 2024 19:04:33 +0800 https://springdoc.cn/what-s-new-in-spring-framework-6-1-1-1/ Spring Framework v6.1.11 正式发布。 ⭐ 新特性 在 SpEL 的 ReflectionHelper 中确保 MethodHandle 的 varargs 组件类型不为 null#33193 在响应过程中出现 Reactor-Netty PrematureCloseException 时，WebClient 异常消息令人困惑 #33127 当发现无效的 factoryBeanObjectType 属性时，在异常中包含 Bean 名称 #33117 在响应式缓存切面使用 Error Handler #33073 getTypeForFactoryMethod 应捕获 NoClassDefFoundError 异常#33075 🐞 Bug 修复 SpEL 无法使用数组调用 varargs MethodHandle 函数 #33191 SpEL 无法调用变量参数为零的 varargs MethodHandle 函数 #33190 嵌套的 Bean 实例 Supplier 调用不会保留先前的工厂方法 #33180 DefaultErrorResponseBuilder 未实现 headers(Consumer) #33156 修复对 Set 方法参数的违规适配 #33150 使用 kotlinx-serialization 时，Web Controller 调用无效正文导致结果为 500，而不是 400 #33138 "file:. https://springdoc.cn/java-executorservice-vs-completablefuture/ Wed, 10 Jul 2024 11:10:34 +0800 https://springdoc.cn/java-executorservice-vs-completablefuture/ 1、简介 本文将带你了解 Java 中用于处理并发任务的两个重要的类：ExecutorService 和 CompletableFuture。 主要介绍它们的功能、如何有效地使用它们、以及它们之间的区别。 2、ExecutorService 概览 ExecutorService 是 Java java.util.concurrent 包中的一个功能强大的接口，可简化对需要并发运行的任务的管理。它抽象掉了线程创建、管理和调度的复杂性，让我们可以专注于需要完成的实际工作。 ExecutorService 提供了 submit() 和 execute() 等方法，用于提交我们希望并发运行的任务。然后，这些任务会进入队列并分配给线程池中的可用线程。如果任务返回结果，我们可以使用 Future 对象来检索结果。不过，使用 Future 上的 get() 等方法检索结果会阻塞调用线程，直到任务完成。 3、CompletableFuture 概览 CompletableFuture 是在 Java 8 中引入的。它专注于以更声明式的方式组合异步操作并处理它们的最终结果。CompletableFuture 充当一个容器，保存异步操作的最终结果。它可能不会立即返回结果，但提供了方法来定义在结果可用时要执行的操作。 ExecutorService 在检索结果时会阻塞线程，而 CompletableFuture 则以非阻塞方式运行。 4、关注点和职责 虽然 ExecutorService 和 CompletableFuture 都能解决 Java 中的异步编程问题，但它们的各自的关注点和职责却截然不同。 4.1、ExecutorService ExecutorService 专注于管理线程池和并发执行任务。它提供了创建具有不同配置（如固定大小、缓存和定时调度）的线程池的方法。 来看一个使用 ExecutorService 创建并维护三个线程的示例，如下： ExecutorService executor = Executors.newFixedThreadPool(3); Future<Integer> future = executor.submit(() -> { // 任务执行逻辑 return 42; }); 调用 newFixedThreadPool(3) 方法会创建一个包含三个线程的线程池，可以确保同时执行的任务不会超过三个。然后使用 submit() 方法提交任务供线程池执行，并返回一个代表计算结果的 Future 对象。 https://springdoc.cn/java-naming-executor-service-thread/ Wed, 10 Jul 2024 10:30:09 +0800 https://springdoc.cn/java-naming-executor-service-thread/ 1、概览 ExecutorService 在 Java 中提供了一种方便的方式来管理线程并执行并发任务。在使用 ExecutorService 时，为线程和线程池分配有意义的名称可以提高调试、监控和理解线程的效果。 本文将带你了解在 Java 的 ExecutorService 中为线程和线程池命名的不同方式。 2、设置线程的名称 如果不使用 ExecutorService，可以在 Java 中通过 Thread#setName 方法轻松设置线程名。 ExecutorService 使用默认的线程池和线程名称，如 pool-1-thread-1、pool-1-thread-2 等，但也可以为 ExecutorService 管理的线程指定自定义的线程名称。 首先，创建一个简单程序，执行 ExecuterService，输出默认的线程和线程池名称： ExecutorService executorService = Executors.newFixedThreadPool(3); for (int i = 0; i < 5; i++) { executorService.execute(() -> System.out.println(Thread.currentThread().getName())); } 运行程序，输出如下: pool-1-thread-1 pool-1-thread-2 pool-1-thread-1 pool-1-thread-3 pool-1-thread-2 2.1、使用自定义 ThreadFactory 在 ExecutorService 中，新线程是通过 ThreadFactory 创建的。ExecutorService 默认使用 Executors.defaultThreadFactory 创建线程来执行任务。 通过向 ExecuterService 提供不同的自定义 ThreadFactory，我们可以更改线程的名称、优先级等。 首先，创建 ThreadFactory 的实现：MyThreadFactory。然后，为 MyThreadFactory 创建的新线程设置自定义线程名称： https://springdoc.cn/jpa-postgresql-json-type-mismatch-errors/ Tue, 09 Jul 2024 10:43:29 +0800 https://springdoc.cn/jpa-postgresql-json-type-mismatch-errors/ 1、简介 本文将带你了解在使用 JPA 与 PostgreSQL 交互时出现异常 “PSQLException error: column is of type json but the expression is of type character varying” 的原因，以及解决办法。 2、常见的原因 在 PostgreSQL 中，JSON 或 JSONB 数据类型用于存储 JSON 数据。但是，如果我们试图将字符串（character varyin）插入到期望使用 JSON 的列中，PostgreSQL 就会抛出 “column is of type json but expression is of type character varying” 错误。这种情况在使用 JPA 和 PostgreSQL 时尤其常见，因为 JPA 可能会尝试将字符串保存到 JSON 列，从而导致此错误。 3、异常演示 创建一个基本的 Spring Boot 项目，在 Maven pom.xml 文件中添加 PostgreSQL 依赖： <dependency> <groupId>org.postgresql</groupId> <artifactId>postgresql</artifactId> <version>42.7.1</version> <scope>runtime</scope> </dependency> 创建一个映射到 student 表的 JPA 实体类： https://springdoc.cn/hibernate-unknownentityexception-could-not-resolve-root-entity/ Tue, 09 Jul 2024 10:26:05 +0800 https://springdoc.cn/hibernate-unknownentityexception-could-not-resolve-root-entity/ 1、概览 本文将带你了解 Hibernate 出现异常 “UnknownEntityException：Could not resolve root entity” 的原因，以及解决办法。 2、理解异常 通常，在 HQL 或 JPQL 查询中解析已知映射实体名称失败时，Hibernate 就会抛出 “UnknownEntityException: Could not resolve root entity” 异常。 简而言之，Hibernate 依赖 JPA 实体来完成对象关系映射的所有工作。因此，它希望查询中指定的实体名称与 @Entity 注解所注解的类名称相匹配。 因此，导致异常的最常见原因之一就是 使用了与有效实体类名称不匹配的名称。 3、示例 知道了导致 Hibernate 出现 UnknownEntityException 的原因后，来看看如何在实践中重现这种情况。 首先，创建一个 Person 类，如下： @Entity public class Person { @Id private int id; private String firstName; private String lastName; // 标准 Getter / Setter 方法省略 } 如上，使用 id、firstName 和 lastName 来定义一个 Person。 @Entity 注解表示 Person 类是一个 JPA 实体，@Id 表示代表主键的字段。 https://springdoc.cn/jdbc-get-insert-id/ Mon, 08 Jul 2024 11:18:50 +0800 https://springdoc.cn/jdbc-get-insert-id/ 1、简介 在使用 JDBC 向数据库插入数据时，如果主键 ID 是自增的，那么我们需要获取到新插入的这条数据的 ID。JDBC 提供了一种在 INSERT 操作后立即获取其自增 ID 的机制。 2、示例项目 为了方便测试，本例使用H2 内存数据库。 在 pom.xml 文件中添加 h2 数据库依赖： <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.1.214</version> </dependency> 首先，连接到 H2 数据库，并在数据库中创建 EMPLOYEES 测试表： private static void populateDB() throws SQLException { String createTable = """ CREATE TABLE EMPLOYEES ( id SERIAL PRIMARY KEY , first_name VARCHAR(50), last_name VARCHAR(50), salary DECIMAL(10, 2) ); """; PreparedStatement preparedStatement = connection.prepareStatement(createTable); preparedStatement.execute(); } 3、检索自增 ID 执行 INSERT 语句时，如果表有自动生成的键（如 MySQL 中的 AUTO_INCREMENT、PostgreSQL 中的 SERIAL 或 H2 数据库中的 IDENTITY），JDBC 可以使用 getGeneratedKeys() 方法检索这些键。 https://springdoc.cn/java-getresourceasstream-vs-fileinputstream/ Wed, 03 Jul 2024 11:52:45 +0800 https://springdoc.cn/java-getresourceasstream-vs-fileinputstream/ 1、概览 本文将带你了解 Java 中读取文件的不同方法之间的差异。主要介绍 getResourceAsStream() 方法和 FileInputStream 类，以及它们的用例。 先说结论，Files.newInputStream() 方法，由于其在内存和性能方面的好处，推荐用于替代 FileInputStream。 2、基础知识 首先来了解一下 getResourceAsStream() 和 FileInputStream 之间的区别以及它们的常见用例。 2.1、使用 getResourceAsStream() 读取文件 getResourceAsStream() 方法从 classpath 读取文件。传递给 getResourceAsStream() 方法的文件路径应相对于 classpath。该方法返回一个可用于读取文件的 InputStream。 这种方法通常用于读取配置文件、properties 文件和其他与应用打包在一起的资源。 2.2、使用 FileInputStream 读取文件 FileInputStream 类用于从文件系统中读取文件。当需要读取未与应用打包在一起的文件时（本地磁盘），该类非常有用。 传递给 FileInputStream 构造函数的文件路径应该是绝对路径或与当前工作目录相对的路径。 FileInputStream 对象由于使用了 finalizers（finalize() 方法），可能存在内存和性能问题。FileInputStream 的更好替代方案是 Files.newInputStream() 方法，其工作方式相同。 本文示例中使用 Files.newInputStream() 方法从文件系统中读取文件。 这些方法通常用于读取文件系统中的外部文件，如日志文件、用户数据文件和 Secret 文件。 3、代码示例 让我们通过一个示例来演示 getResourceAsStream() 和 Files.newInputStream() 的用法。 创建一个简单的工具类，使用这两种方法读取文件。然后，通过从 classpath 和文件系统中读取示例文件来测试这两种方法。 3.1、使用 getResourceAsStream() 首先，来看看 getResourceAsStream() 方法的用法。 创建一个名为 FileIOUtil 的类，并添加一个从指定资源中读取文件的方法： static String readFileFromResource(String filePath) { try (InputStream inputStream = FileIOUtil. https://springdoc.cn/spring-ai-redis-rag-app/ Wed, 03 Jul 2024 10:58:31 +0800 https://springdoc.cn/spring-ai-redis-rag-app/ 1、概览 在本教程中，我们将使用 Spring AI 框架和 RAG（检索增强生成）技术构建一个 ChatBot（聊天机器人）。在 Spring AI 的加持下，我们将与 Redis Vector（向量）数据库集成，以存储和检索数据，从而增强 LLM（大型语言模型）的提示功能。一旦 LLM 接收到包含相关数据的提示，它就会有效地用自然语言生成带有最新数据的响应，以回应用户的查询。 2、RAG 是什么？ LLM 是根据互联网上的大量数据集预先训练的机器学习模型。要使 LLM 在私营企业中发挥作用，我们必须根据特定组织的知识库对其进行微调。然而，微调通常是一个耗时的过程，需要大量的计算资源。此外，经过微调的 LLM 很有可能会对查询生成不相关或误导性的响应。这种行为通常被称为 LLM 幻觉（LLM Hallucinations）。 在这种情况下，RAG 是一种优秀的技术，用于限制或将 LLM 的响应置于特定上下文中。向量数据库在 RAG 架构中发挥着重要作用，为 LLM 提供上下文信息。但是，在 RAG 架构中使用矢量（向量）数据库之前，应用必须通过 ETL（提取、转换和加载）流程对其进行填充： Reader 从不同源检索组织的知识库文档。然后，Transformer（转换器）将检索到的文档分割成小块，并使用嵌入模型对内容进行矢量化。最后，Writer 将向量或 Embedding 加载到向量数据库。向量数据库是专门的数据库，可以在多维空间中存储这些 Embedding。 在 RAG 中，如果矢量数据库定期从组织的知识库中更新，那么 LLM 就能对几乎实时的数据做出响应。 一旦矢量数据库中的数据准备就绪，应用就可以使用它来检索用户查询的上下文数据： 应用将用户查询与矢量数据库中的上下文数据相结合形成提示，最后将其发送给 LLM。LLM 在上下文数据的范围内用自然语言生成回复，并将其发送回应用。 3、使用 Spring AI 和 Redis 实现 RAG Redis Stack 提供矢量搜索服务，我们将使用 Spring AI 框架与之集成，并构建一个基于 RAG 的 ChatBot（聊天机器人）应用。此外，我们还要使用 OpenAI 的 GPT-3. https://springdoc.cn/java-postgresql-insert-json-object-preparedstatement/ Wed, 03 Jul 2024 10:10:43 +0800 https://springdoc.cn/java-postgresql-insert-json-object-preparedstatement/ 1、简介 在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL 凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。 在 Java 中，我们通常使用 JDBC 与数据库进行交互，本文将带你了解如何使用 Java 的 PreparedStatement 将 JSON 对象插入 PostgreSQL 数据库。 2、依赖 首先，需要设置环境。除了安装和运行 PostgreSQL，还需要在项目的依赖中添加 PostgreSQL JDBC 驱动和 org.json 库。 2.1、安装和运行 PostgreSQL 如果你还没有安装 PostgreSQL，可以从 PostgreSQL 官方网站 下载并安装。PostgreSQL 支持 JSON 已经有相当长的时间了，你可以选择从 PostgreSQL 9 开始的任何版本。本文使用最新的稳定版本，即 PostgreSQL 16。 在继续阅读之前，你需要确保 PostgreSQL 正常运行，并可通过必要的凭据访问。 2.2、添加 PostgreSQL JDBC 驱动 将 PostgreSQL JDBC 驱动添加到项目的依赖中。 对于 Maven 项目，可以在 pom.xml 中添加如下 依赖： <dependency> <groupId>org.postgresql</groupId> <artifactId>postgresql</artifactId> <version>42.7.3</version> </dependency> 2.3、添加 JSON 依赖 要在 Java 代码中处理 JSON 数据，还需要添加 JSON 库依赖。目前有几种流行的 Java JSON 库，如 Jackson、Gson、FastJson 和 org. https://springdoc.cn/java-protocol-buffer-grpc-differences/ Tue, 02 Jul 2024 11:47:25 +0800 https://springdoc.cn/java-protocol-buffer-grpc-differences/ 1、概览 在软件开发中，微服务架构已成为创建可扩展和可维护系统的一种受欢迎的方法。在微服务之间进行有效的通信至关重要，其中涉及的技术包括 REST、消息队列、Protocol Buffer（Protobuf）和 gRPC等。 本文将重点介绍 Protobuf 和 gRPC，研究它们的异同、优缺点，从而全面了解它们在微服务架构中的作用。 2、Protobuf Protocol Buffer 是一种不依赖语言和平台的结构化数据序列化和反序列化机制。其创建者谷歌宣称，与 XML 和 JSON 等其他类型的 Payload 相比，Protocol Buffer 更快、更小、更简单。 Protobuf 使用 .proto 文件来定义数据的结构。每个文件都描述了可能从一个节点传输到另一个节点或存储在数据源中的数据。定义了 Schema 后，就可以使用 Protobuf 编译器（protoc）生成各种语言的源代码： syntax = "proto3" message Person { string name = 1; int32 id = 2; string email = 3; } 这是一个有三个字段的 Person 类型的简单消息协议。name 和 email 是 String 类型，而 id 是整数类型。 2.1、Protobuf 的优势 来看看使用 Protobuf 的一些优势。 Protobuf 数据结构紧凑，易于序列化和反序列化，因此在速度和存储方面都非常高效。 Protobuf 支持多种编程语言，如 Java、C++、Python、Go 等，促进了无缝跨平台数据交换。 它还能在不中断已部署程序的情况下添加或删除数据结构中的字段，从而实现无缝版本控制和更新。 https://springdoc.cn/spring-artificial-intelligence-structure-output/ Tue, 02 Jul 2024 10:50:29 +0800 https://springdoc.cn/spring-artificial-intelligence-structure-output/ 1、简介 本文将带你了解如何格式化 Spring AI 的输出结构，使其更易于使用且更加直观。 2、聊天模型简介 ChatModel 接口是向 AI 模型发出提示的基本结构： public interface ChatModel extends Model<Prompt, ChatResponse> { default String call(String message) { // 忽略实现。。。 } @Override ChatResponse call(Prompt prompt); } call() 方法的作用是向模型发送消息并接收响应，仅此而已。 自然而然地，我们期望提示和响应是 String 类型。然而，现代模型的实现通常具有更复杂的结构，可以进行更精细的调整，提高模型的可预测性。例如，虽然可用的默认 call() 方法接受 String 参数，但更实用的做法是使用 Prompt。Prompt 可以包含多个消息或包括诸如 “温度” 之类的选项，以调节模型的表现力。 我们可以自动装配 ChatModel 并直接调用它。例如，如果我们的依赖中有用于 OpenAI API 的 spring-ai-openai-spring-boot-starter，那么就会自动注入 OpenAI 的实现 OpenAiChatModel。 3、结构化输出 API 要获得数据结构化的输出，Spring AI 提供了使用结构化输出 API 封装 ChatModel 调用的工具。此 API 的核心接口是 StructuredOutputConverter（结构化输出转换器）： public interface StructuredOutputConverter<T> extends Converter<String, T>, FormatProvider {} 它结合了另外两个接口，第一个是 FormatProvider： https://springdoc.cn/java-solve-unsupportedtemporaltypeexception-unsupported-field-instantseconds/ Tue, 02 Jul 2024 10:17:10 +0800 https://springdoc.cn/java-solve-unsupportedtemporaltypeexception-unsupported-field-instantseconds/ 1、概览 在处理日期时，我们经常使用 Date/Time API。但是，如果操作不当，操作或访问时间数据可能会导致错误和异常。其中一个经常遇到的异常就是 UnsupportedTemporalTypeException: “Unsupported Field: InstantSeconds”，通常表示指定的 Temporal（时态）对象不支持 InstantSeconds 字段 。 本将带你了解出现 UnsupportedTemporalTypeException 异常的原因，以及解决办法。 2、实例 在介绍解决方案之前，先通过一个实际例子来了解导致该异常的根本原因。 根据文档，UnsupportedTemporalTypeException 表示不支持 ChronoField 或 ChronoUnit。换句话说，当在不支持特定字段的时间（Temporal）对象上使用不支持的字段时，就会引发此异常。 异常堆栈中的 “Unsupported Field: InstantSeconds” 消息说明了一切。它表明字段 InstantSeconds 出了问题，该字段表示从纪元（Epoch）开始的秒数的连续计数的概念。 简而言之，并非所有 Date / Time API 提供的时间对象都支持该字段。例如，尝试将涉及 InstantSeconds 的操作应用到 LocalDateTime、LocalDate 和 LocalTime 时，会导致 UnsupportedTemporalTypeException 异常。 现在，来看看如何重现异常。如下，尝试把 LocalDateTime 转换为 Instant： @Test void givenLocalDateTime_whenConvertingToInstant_thenThrowException() { assertThatThrownBy(() -> { LocalDateTime localDateTime = LocalDateTime.now(); long seconds = localDateTime.getLong(ChronoField.INSTANT_SECONDS); Instant instant = Instant.ofEpochSecond(seconds); }).isInstanceOf(UnsupportedTemporalTypeException.class) .hasMessage("Unsupported field: InstantSeconds"); } 上述测试代码会失败，因为我们试图使用 LocalDateTime 实例来访问 ChronoField. https://springdoc.cn/spring-boot-podman-desktop/ Mon, 01 Jul 2024 11:09:16 +0800 https://springdoc.cn/spring-boot-podman-desktop/ 1、概览 本文将带你了解如何使用 Podman Desktop 对 Spring Boot 应用进行容器化。Podman 是一种容器化工具，它允许我们在不需要守护进程的情况下管理容器。 Podman Desktop 是一款具有图形用户界面（GUI）的桌面应用，用于使用 Podman 管理容器。 为了演示其用法，我们要创建一个简单的 Spring Boot 应用，构建容器镜像，并使用 Podman Desktop 运行容器。 2、安装 Podman Desktop 我们需要在本地计算机上 安装 Podman Desktop 才能开始使用。它适用于 Windows、macOS 和 Linux 操作系统。下载安装程序后，按照安装说明在机器上安装 Podman Desktop 即可。 以下是设置 Podman Desktop 的几个重要步骤： 机器上应已安装 Podman。如果没有安装，Podman Desktop 会提示并为我们安装。 Podman 准备就绪后，系统会提示我们启动 Podman 虚拟机。我们可以选择默认设置，也可以根据需要自定义设置。在运行容器之前，这是必须的。 此外，对于 Windows，需要启用/安装 WSL2（Windows Subsystem for Linux），然后才能运行 Podman。 在安装过程结束时，我们应该有一个正在运行的 Podman 虚拟机，并可以使用 Podman Desktop 进行管理。 可以在 “Dashboard”（仪表盘）部分看到： 3、创建 Spring Boot 应用 创建一个小型 Spring Boot 应用。该应用有一个 REST Controller，当我们访问 /hello 端点时，它返回一条 "Hello, World! https://springdoc.cn/spring-boot-test-cross-origin-resource-sharing/ Mon, 01 Jul 2024 10:32:15 +0800 https://springdoc.cn/spring-boot-test-cross-origin-resource-sharing/ 1、简介 跨源资源共享（Cross-Origin Resource Sharing，CORS）是一种安全机制，允许网页从一个源访问另一个源的资源。它由浏览器强制执行，以防止网站向不同域发出未经授权的请求。 在使用 Spring Boot 构建 Web 应用时，必须正确测试 CORS 配置，以确保应用能安全地与授权的源交互，同时阻止未经授权的源。 通常情况下，我们只有在应用部署后才会发现 CORS 问题。通过尽早测试 CORS 配置，可以在开发过程中发现并解决这些问题，从而节省时间和精力。 本文将带你了解讨如何使用 MockMvc 编写有效的测试来验证 CORS 配置。 关于 Spring Boot 中 CORS 跨域配置的详细内容，你可以参阅 “在 Spring 应用中处理 CORS 跨域” 和 “Spring 和 CORS 跨域” 这两篇文章。 2、Spring Boot 配置 CORS 在 Spring Boot 应用中配置 CORS 有多种方法。在本文中，我们使用 Spring Security 并自定义 CorsConfigurationSource： private CorsConfigurationSource corsConfigurationSource() { CorsConfiguration corsConfiguration = new CorsConfiguration(); corsConfiguration.setAllowedOrigins(List.of("https://baeldung.com")); corsConfiguration.setAllowedMethods(List.of("GET")); corsConfiguration.setAllowedHeaders(List.of("X-Baeldung-Key")); corsConfiguration.setExposedHeaders(List.of("X-Rate-Limit-Remaining")); UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(); source. https://springdoc.cn/java-psqlexception-operator-does-not-exist-character-varying-uuid/ Mon, 01 Jul 2024 10:10:10 +0800 https://springdoc.cn/java-psqlexception-operator-does-not-exist-character-varying-uuid/ 1、简介 本文将带你了解 JPA 与 PostgreSQL 交互时出现 PSQLException 异常：“Operator Does Not Exist: Character Varying = UUID” 的原因，以及如何处理和避免该异常。 2、异常原因 PostgreSQL 区分 Character Varying（字符串）和 UUID 数据类型。这种区分要求在这些类型之间进行比较时进行 显式类型转换。因此，当我们尝试直接将 UUID 值与字符串（VARCHAR）列进行比较时，PostgreSQL 会抛出异常，因为它缺乏用于这种特定类型比较的操作符。 举个例子，有一个 User 实体，其 varchar 列为 uuid： @Entity @Table(name = "User_Tbl") public class User{ @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(columnDefinition = "varchar") private UUID uuid; // Gette / Setter 方法省略 } 当尝试使用 UUID 值查询数据库时，会出现异常： // UUID UUID testId = UUID.fromString("c3917b5b-18ed-4a84-a6f7-6be7a8c21d66"); User user = new User(); user. https://springdoc.cn/java-enums-jpa-postgresql/ Fri, 28 Jun 2024 12:05:22 +0800 https://springdoc.cn/java-enums-jpa-postgresql/ 1、简介 本文将带你了解 Java 枚举、JPA 和 PostgreSQL 枚举的概念，以及如何将它们结合使用，在 Java 枚举和 PostgreSQL 枚举之间创建无缝映射。 2、Java 枚举 Java 枚举（Enum）是一种特殊类型的类，用于表示一组固定数量的常量。枚举用于定义一组具有底层类型（如字符串或整数）的命名值。当我们需要定义一组在应用中具有特定含义的命名值时，枚举非常有用。 下面是一个 Java 枚举的示例： public enum OrderStatus { PENDING, IN_PROGRESS, COMPLETED, CANCELED } 在本例中，OrderStatus 枚举定义了四个常量。这些常量可以在我们的应用中用来表示订单的状态。 3、使用 @Enumerated 注解 在 JPA 中使用 Java 枚举时，需要用 @Enumerated 来注解枚举字段，以指定如何将枚举值存储到数据库中。 首先，定义一个名为 CustomerOrder 的实体类，并用 @Entity 进行注解，以标记其用于 JPA 持久化： @Entity public class CustomerOrder { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Enumerated() private OrderStatus status; // 其他的字段和方法省略 } 默认情况下，JPA 将枚举值存储为整数（Integer），代表枚举常量的序号位置（ordinal()）。例如，上文中的 OrderStatus 枚举值 PENDING、IN_PROGRESS、COMPLETED 和 CANCELED，默认行为将分别把它们存储为整数 0、1、2 和 3。由此产生的数据库表将有一个小 int 类型的状态列，其值为 0 至 3： https://springdoc.cn/spring-logbook-http-logging/ Fri, 28 Jun 2024 11:10:57 +0800 https://springdoc.cn/spring-logbook-http-logging/ 1、概览 Logbook 是一个可扩展的 Java 库，可为不同的客户端和服务器端提供完整的请求和响应日志。它允许开发人员记录应用接收或发送的任何 HTTP 流量。这可用于日志分析、审计或分析流量问题。 本文将带了解如何在 Spring Boot 中整合 Logbook，以及如何使用 Logbook 记录 HTTP 请求和响应。 2、依赖 在 Spring Boot 中添加 logbook-spring-boot-starter 依赖： <dependency> <groupId>org.zalando</groupId> <artifactId>logbook-spring-boot-starter</artifactId> <version>3.9.0</version> </dependency> 你可以在 Maven Central 中找到最新版本的 Logbook。 3、配置 Logbook 与 Spring Boot 应用中的 logback 日志配合使用。 我们需要在 logback-spring.xml 和 application.properties 文件中添加配置。 在 pom.xml 中添加 Logbook 库后，Spring Boot 就会自动配置 Logbook 库，我们需要做的就是在 application.properties 文件中添加日志级别： logging.level.org.zalando.logbook.Logbook=TRACE 启用 TRACE 日志级别，即可记录 HTTP 请求和响应。 此外，还要在 logback-spring.xml 文件中添加了 Logbook 配置： <logger name="org.zalando.logbook" level="INFO" additivity="false"> <appender-ref ref="RollingFile"/> </logger> 添加完成后，就可运行应用了。每次 HTTP 请求调用后，Logbook 都会将请求和响应记录到 logback-spring. https://springdoc.cn/spring-data-jpa-max-value/ Fri, 28 Jun 2024 10:11:02 +0800 https://springdoc.cn/spring-data-jpa-max-value/ 1、简介 本文将带你了解如何使用 Spring Data JPA 检索数据列中的最大值（Max Value）。 2、示例 首先，添加 spring-boot-starter-data-jpa 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> 然后，定义一个简单的 Employee 实体表示员工： @Entity public class Employee { @Id @GeneratedValue private Integer id; private String name; private Long salary; // 工资 // 构造函数、Getter、Setter 方法省略 } 接下来，看看有哪些方法可以检索出所有员工中薪水（salary）列的最大值。 3、使用 Repository 的派生查询 Spring Data JPA 提供了一个强大的机制，可以使用 Repository 方法来定义自定义查询。其中之一是派生查询，它允许我们通过声明方法名来实现SQL查询。 创建 Employee 实体类的 Repository 接口： public interface EmployeeRepository extends JpaRepository<Employee, Integer> { Optional<Employee> findTopByOrderBySalaryDesc(); } 如上，我们实现了一个方法 findTopByOrderBySalaryDesc，该方法使用查询派生机制生成相应的 SQL。根据方法名，它将按照工资（salary）降序对所有员工进行排序，然后返回第一个员工，即工资最高的员工。 该方法会返回一个加载了所有属性的实体。如果我们只想检索一个工资（salary）值，可以使用投影查询： 创建 EmployeeSalary 投影接口： https://springdoc.cn/go-impl-of-spring-like-declarative-transactions/ Mon, 24 Jun 2024 19:02:00 +0800 https://springdoc.cn/go-impl-of-spring-like-declarative-transactions/ 事务（TRANSACTION），是指一组操作的集合，这些操作要么全部成功，要么全部失败。其目的是在出现错误、系统崩溃或其他意外情况下，保证数据的一致性和完整性。 事务通常具有以下四个重要的特性，这些特性被统称为 ACID 属性： Atomicity（原子性）: 定义: 事务中的所有操作要么全部完成，要么全部不完成，任何一个操作失败都会导致整个事务的失败，并且事务的所有操作都会被回滚（撤销）。 示例: 银行转账操作，如果从一个账户扣款后无法在另一个账户中存款，那么整个操作将回滚，不会执行任何更改。 Consistency（一致性）: 定义: 事务只能把数据库从一种一致状态转换到另一种一致状态。在事务开始之前和结束之后，数据库的完整性约束没有被破坏。 示例: 在一个事务中插入数据时，如果插入的数据违反了数据库的完整性约束（例如唯一约束），那么这个事务将失败，数据库将保持一致状态。 Isolation（隔离性）: 定义: 事务的执行是隔离的，多个事务并发执行时，一个事务的执行不会受到其他事务的干扰。隔离性确保了并发事务的执行结果与按顺序执行的结果相同。 示例: 两个用户同时购买同一件商品，隔离性确保每个用户看到的库存是正确的，避免超卖的情况。 Durability（持久性）: 定义: 一旦事务提交，其结果将永久保存在数据库中，即使系统崩溃也不会丢失。 示例: 即使在事务提交后立即发生系统崩溃，事务的结果也会保存在数据库中，重启系统后数据依然存在。 以 MYSQL 关系型数据库为例，事务的使用如下： -- 开始事务 BEGIN TRANSACTION; -- TODO 执行业务 1 -- TODO 执行业务 2 -- TODO 执行业务 3 -- .... -- 提交事务 COMMIT; -- 或者，回滚事务 ROLLBACK; 其中，BEGIN TRANSACTION、COMMIT 以及 ROLLBACK 都是事务固定的模板代码，当代的大多数框架都会自动帮我们进行处理。 Spring 对事务的支持 Spring 对关系型数据库中的事务提供强大的支持，包括声明式事务、TransactionTemplate 模板事务等等。 @Transactional 声明式事务 实际开发中，最常用的就是通过 @Transactional 注解来声明事务方法。事务方法会在执行开始前自动开始事务，在方法结束后自动提交事务，在执行过程中如果遇到异常则自动回滚事务。 import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service @Transactional // 为 public 方法开启事务 public class FooService { public void service () { // TODO 在事务中执行业务 } } 在类上注解 @Transactional，则会为当前类中所有 public 方法开启声明式事务。也可以单独注解在方法上，则会覆盖类上的 @Transactional 定义。 https://springdoc.cn/spring-boot-3-3-1-available-now/ Fri, 21 Jun 2024 13:25:34 +0800 https://springdoc.cn/spring-boot-3-3-1-available-now/ Spring Boot v3.3.1 发布了，这是 Spring Boot v3.3 的第一个 BUG 修复版本。 🐞 Bug 修复 添加 org.springframework.boot.jdbc.parameters 标签后，SQL Server JDBC URL 出现格式错误 #41169 git-commit-id Maven 插件升级后，无法强制转换 Git instant 属性 #41152 将 status code 排除在 DefaultErrorAttributes 之外会引发 NPE（控指针异常）#41141 使用 devtools 进行 Spring Boot 远程重启时，在使用 java -jar 运行时会导致 Tomcat 错误 “factory already defined” #41107 MongoHealthIndicator 在严格设置下不符合 Mongo 稳定（Stable） API #41104 Bitnami MongoDB 服务连接失败 #41097 构建镜像时需要 Builder 指定一个栈（Stack）#41091 如果未包含 java.sql 模块，DataSourceProperties 绑定失败 #41084 使用 include 时，AOT 导致 Logback 配置错误 #41081 配置了 Builder 和 Buildpack 时，镜像构建挂起 #41049 尝试使用 Spring Boot 配置的 SSL 时，使用 Tomcat 的 HttpNio2Protocol 会抛出 IllegalArgumentException #41010 当包含 Multi-Release: true 的依赖项且 META-INF/versions 中存在意外文件条目时，Uber jar 启动失败 #41006 使用 Jetty 时，可执行 war 文件中可能找不到 JSP 相关资源 #40996 无论配置的最大线程数是多少，tomcat. https://springdoc.cn/java-upcasting-vs-downcasting/ Fri, 21 Jun 2024 11:23:38 +0800 https://springdoc.cn/java-upcasting-vs-downcasting/ 1、简介 了解如何处理 Java 类型层次结构中的对象对于编写灵活和可维护的代码至关重要。在这个领域中，两个基本概念是向上转型（Upcasting）和向下转型（Downcasting）。 本文将带你深入了解这些概念，探索它们之间的区别，以及它们在 Java 中的原理。 2、Java 中的类型转换 Java 是一种面向对象的编程语言（Object Oriented Programming，OOP），允许在其类型系统中将一种类型转换为另一种类型。转换是将一种类类型的引用转换为另一种类类型的过程。具体来说，Java 中主要有两种类型的转换：向上转型（Upcasting）和向下转型（Downcasting）。 假设我们有一个类的层次结构，其中 Dog 是 Animal 的子类。下图显示了向上转型（Upcasting）和向下转型（Downcasting）在这个层次结构中的工作原理： 向上转型（Upcasting）箭头从 Dog 类移动到 Animal 类，显示了子类引用（Dog）如何泛化为父类引用（Animal）。而，向下转型（Downcasting）箭头从 Animal 类返回 Dog 类，显示父类引用（Animal）如何再次被指定为子类引用（Dog）。 但是，如果尝试使用 Animal 引用实例化 Dog 对象，则会因类型不兼容而导致编译错误。 Dog dog = new Animal(); //异常 ClassCastException 3、Java 向上转型 向上转型（Upcasting）是指将子类引用转换为父类引用。这种类型的转换是隐式的，在处理多态性时经常使用它。 向上转型（Upcasting）允许我们将一个子类的对象当作一个父类的对象来处理： class Animal { public void makeSound() { System.out.println("Animal sound"); } } class Dog extends Animal { public void makeSound() { System.out.println("Bark"); } public void fetch() { System. https://springdoc.cn/java-sql-blob-jackson-serialize-deserialize/ Wed, 19 Jun 2024 17:42:55 +0800 https://springdoc.cn/java-sql-blob-jackson-serialize-deserialize/ 1、简介 本文将带你了解如何使用 Jackson 序列化和反序列化 java.sql.Blob 对象。 java.sql.Blob 表示 Java 中的二进制大对象（Binary Large Object，Blob），可以存储大量二进制数据。在使用 Jackson 处理 JSON 序列化和反序列化时，处理 Blob 对象可能比较棘手，因为 Jackson 并不直接支持它们。不过，我们可以创建自定义的序列化器（Serializer）和反序列化器（Deserializer）来处理 Blob 对象。 2、依赖和示例项目 首先，在 pom.xml 中添加 jackson-databind 依赖： <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.12.3</version> </dependency> 然后，创建一个简单的 User POJO，其中包含 id、name 和 Blob 类型的 profilePicture（图片数据）： public class User { private int id; private String name; private Blob profilePicture; // 构造函数，Getter/Setter 省略 } 3、定义 Blob 序列化器 定义一个序列化器（Serializer），将 User 的 profilePicture 属性转换为 Base64 编码的二进制字符串： @JacksonStdImpl public class SqlBlobSerializer extends JsonSerializer<Blob> { @Override public void serialize(Blob value, JsonGenerator gen, SerializerProvider serializers) throws IOException { try { byte[] blobBytes = value. https://springdoc.cn/spring-webclient-wiremock-integration-testing/ Wed, 19 Jun 2024 11:44:43 +0800 https://springdoc.cn/spring-webclient-wiremock-integration-testing/ 1、简介 Spring WebClient 是一款非阻塞、响应式的 HTTP 客户端，而 WireMock 是一个强大的用于模拟基于 HTTP 的 API 的工具。 2、依赖和示例 首先，需要在 Spring Boot 项目中添加必要的依赖。 在 pom.xml 中添加 spring-boot-starter-flux（WebClient） 和 spring-cloud-starter-wiremock（WireMock Server）依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-contract-wiremock</artifactId> <version>4.1.2</version> <scope>test</scope> </dependency> 假设，我们的应用需要调用外部天气 API，以获取给定城市的天气数据。 定义 WeatherData POJO： public class WeatherData { private String city; private int temperature; private String description; // 构造函数、Getter/Setter 方法省略 我们要使用 WebClient 和 WireMock 进行集成测试，以测试这个功能。 3、使用 WireMock API 进行集成测试 首先用 WireMock 和 WebClient 设置 Spring Boot 测试类： https://springdoc.cn/spring-security-detect-compromised-passwords/ Wed, 19 Jun 2024 10:42:10 +0800 https://springdoc.cn/spring-security-detect-compromised-passwords/ 1、概览 在构建处理敏感数据的 Web 应用时，确保用户密码的安全性非常重要。密码安全的一个重要方面是检查密码是否泄露，这通常是由于密码出现在 数据泄露事件 中。 Spring Security 6.3 引入了一项新功能，让我们可以轻松检查密码是否被已泄露。 本文将带你了解 Spring Security 中新的 CompromisedPasswordChecker API 以及如何将其集成到 Spring Boot 应用中。 2、密码泄露 密码泄露是指在数据泄露事件中暴露的密码，使其容易受到未经授权的访问。攻击者通常在凭证填充和密码填充攻击中使用这些泄露的密码，在多个网站上使用泄露的用户名-密码对，或在多个账户上使用通用密码。 要降低这种风险，关键是要在创建账户前检查用户密码是否泄露。 同样重要的是要注意，以前有效的密码可能会随着时间的推移而泄露，因此建议不仅在创建账户时，而且在登录过程中或任何允许用户更改密码的过程中都要检查密码是否泄露。如果登录尝试因检测到密码泄露而失败，可以提示用户重设密码。 3、CompromisedPasswordChecker Spring Security 提供了一个简单的 CompromisedPasswordChecker 接口，用于检查密码是否被泄露： public interface CompromisedPasswordChecker { CompromisedPasswordDecision check(String password); } 该接口只暴露了一个 check() 方法，该方法将密码作为输入，并返回一个 CompromisedPasswordDecision 的实例，表明密码是否已被破解/泄露。 check() 方法需要明文密码，因此必须在使用 PasswordEncoder 加密密码之前调用该方法。 3.1、配置 CompromisedPasswordChecker Bean 要在应用中启用密码泄露检查，需要声明 CompromisedPasswordChecker 类型的 Bean： @Bean public CompromisedPasswordChecker compromisedPasswordChecker() { return new HaveIBeenPwnedRestApiPasswordChecker(); } HaveIBeenPwnedRestApiPasswordChecker 是 Spring Security 提供的 CompromisedPasswordChecker 的默认实现。 https://springdoc.cn/getting-started-with-spring-ai-and-open-ai/ Tue, 18 Jun 2024 11:46:14 +0800 https://springdoc.cn/getting-started-with-spring-ai-and-open-ai/ Open AI 和 Spring AI 简介 当 OpenAI 发布 ChatGPT 时，它在全球掀起了一场风暴。这是第一次有语言模型能够根据提示生成类似人类的回答。此后，OpenAI 又发布了其他几个模型，包括可以根据文字提示生成图像的 DALL-E。 Spring AI 是一个 Java 库，为与 LLM 模型交互提供了一个简单易用的接口。Spring AI 提供了与各种 LLM（如 Open AI、Azure Open AI、Hugging Face、Google Vertex、Ollama、Amazon Bedrock 等）交互的高级抽象。 本文将带你了解如何使用 Spring AI 与 Open AI 能进行交互。 首先，需要在 OpenAI 上创建账户并获取 API Key。 访问 OpenAI Platform 并创建账户。 在控制面板中，点击左侧导航菜单中的 API Keys，创建一个新的 API Key。 如果你是新用户，你可能会获得一些免费点数来使用 OpenAI API。否则，你需要购买点数才能使用 OpenAI API。 获得 API KEY 后，把它添加到环境变量 OPENAI_API_KEY 中。 export OPENAI_API_KEY=<your-api-key> 创建 Spring AI 项目 使用 Spring Initializr 创建一个新的 Spring Boot 项目。 https://springdoc.cn/tomcat-zero-downtime-web-app-upgrade-parallel-deployment/ Tue, 18 Jun 2024 10:54:19 +0800 https://springdoc.cn/tomcat-zero-downtime-web-app-upgrade-parallel-deployment/ 1、概览 Apache Tomcat，简称 Tomcat，是 Jakarta Servlet 规范的开源实现。它作为 Web 服务器接收 HTTP 或 WebSocket 请求，并调用负责的 Servlet 来处理请求。 本文将带你了解 Tomcat 中的并行部署（Parallel Deployment），以及如何实现不停机升级 Web 应用。 2、Tomcat 部署模式 我们可以通过两种方式使用 Apache Tomcat 为 Web 应用提供服务。第一种方法是将 Tomcat 程序嵌入 Java 应用本身。或者，可以将 Apache Tomcat 作为一个专用的 Web 服务器进程运行，为一个或多个 Web 应用提供服务。在这种模式下，开发人员会将 Web 应用打包成 WAR （Web Application Archive，Web 应用归档）包。然后，Web 服务器管理员会将 Web 应用部署到 Tomcat Web 服务器上。 独立的 Tomcat 部署模式现在不怎么流行了，但是也有好处。多个不同的 Web 应用使用同一个 Tomcat 服务器会节省一定的资源。 将 Tomcat 作为独立 Web 服务器运行时，需要了解如何对运行中的 Web 应用进行不停机重新部署。与通常将此任务委托给 Kubernetes 等外部协调器的容器化 Web 应用相反，Tomcat 中的部署依赖于 Tomcat 服务器，以最大限度地减少 Web 应用升级的停机时间。 https://springdoc.cn/how-to-control-the-loading-order-of-beans-in-spring/ Tue, 18 Jun 2024 10:12:41 +0800 https://springdoc.cn/how-to-control-the-loading-order-of-beans-in-spring/ 先说结论，使用 @Order 注解或者是实现 Ordered 接口并不能控制 Bean 的加载顺序。 一、@Order 注解和 Ordered 接口 在 Spring 框架中，@Order 是一个非常实用的元注解，它位于 spring-core 包下，主要用于控制某些特定上下文（Context）中组件的执行顺序或排序，但它并不直接控制 Bean 的初始化顺序。 1.1、用途 @Order 注解或者是 Ordered 接口，常见的用途主要是两种： 定义执行顺序：当多个组件（如 Interceptor、Filter、Listrner 等）需要按照特定的顺序执行时，@Order 注解可以用来指定这些组件的执行优先级。数值越小，优先级越高，相应的组件会更早被执行或被放置在集合的前面（@Order 注解接受一个整数值，这个值可以是负数、零或正数。Spring 框架提供了 Ordered.HIGHEST_PRECEDENCE（默认最低优先级）和 Ordered.LOWEST_PRECEDENCE（默认最高优先级）常量，分别对应于 Integer.MIN_VALUE 和 Integer.MAX_VALUE，可以方便地设定优先级。 集合排序：当相同类型的组件被自动装配到一个集合中时，@Order 注解会影响它们在这个集合中的排列顺序。 1.2、使用场景 经典的使用场景如下。 拦截器的排序 在 Spring MVC 中，可以使用 @Order 来控制拦截器（Interceptor）的执行顺序。 Spring Security Filter 在 Spring Security 中，过滤器链（Filter Chain）的顺序通过 @Order 来定义，确保正确的安全处理流程。 // HttpSecurity 的 performBuild 方法 @Override protected DefaultSecurityFilterChain performBuild() { // 对 Filter 进行排序 this. https://springdoc.cn/advertising/ Tue, 18 Jun 2024 08:41:19 +0800 https://springdoc.cn/advertising/ 『spring 中文网』致力于为国内开发者提供优质的中文文档、教程和资讯。网站内容的维护和服务器都需要时间和金钱的支出。所以我们寻求赞助，希望通过接入广告的方式减轻我们的运营成本，帮助我们产出更优质的文档和内容。同时，也期望『spring 中文网』能有一个机会，向用户展示你的产品、服务、品牌。 秉持对读者负责的态度，我们对投放的广告也有一点要求：广告内容，以及所提供的产品、服务，必须要符合社会主义核心价值观。如果广告主私自修改广告链接，跳转到非法应用、服务，本站会立即下线广告且不做通知、不退款。 你可以联系微信：KevinBlandy 或者邮箱：747692844@qq.com 沟通广告投放事宜。 用户数据 近半年的真实用户数据： 月份 PV UV IP 2024-05 122,868 82,831 79,466 2024-04 127,037 82,741 77,955 2024-03 105,493 67,329 65,606 本站的真实用户数据是公开的，你可以点击 51.LA 网站统计 来查看。 需要说明的是，上述统计并 未包含 『spring 中文网』中所有 中文文档 的访问的统计，中文文档页面目前不提供广告位，且使用了独立的流量统计服务（百度）。 赞助商广告位 目前有 2 个广告位可以投放，分别是 顶部 Banner 和 侧栏 Banner，均是全站显示（除了中文文档页面）。 鸣谢列表 感谢你们对『spring 中文网』的支持，谢谢。 2024 年 瓜子影视 https://springdoc.cn/spring-avoid-no-multipart-boundary-was-found/ Sat, 15 Jun 2024 10:50:54 +0800 https://springdoc.cn/spring-avoid-no-multipart-boundary-was-found/ 1、简介 本文将带你了解在 Spring 中处理文件上传（Multipart）请求时出现异常：“No Multipart Boundary Was Found” 的原因，以及解决办法。 2、理解 Multipart 请求 简而言之，Multipart 请求是一种 HTTP 请求，它在一条消息的请求体中传输一种或多种不同的数据。请求体被分成多个部分，请求中的每个部分都可能代表不同的文件或数据。 通常使用它来传输或上传文件、交换电子邮件、流媒体或提交 HTML 表单，并使用 Content-Type 标头来指明在请求中发送的数据类型。 来看看 Multipart 请求需要设置哪些值。 2.1、主类型 主类型（顶级类型）指定了我们发送的内容的主要类别。如果我们在单个 HTTP 请求中提交多种数据类型，则需要将 Content-Type Header 值设置为 multipart。 2.2、子类型 除了顶级类型外，Content-Type Header 值还包含一个强制的子类型。子类型值提供了有关数据格式的附加信息。 在不同的 RFC 中定义了多种 multipart 子类型。例如 multipart/mixed、multipart/alternative、multipart/related 和 multipart/form-data（常用）。 由于我们在一个请求中封装了多种不同的数据类型，因此需要一个额外的参数来分隔 multipart 消息的不同部分：即，boundary 参数。 2.3、Boundary 参数 Boundary 指令（参数）是 multipart Content-Type 的强制值，它指定了封装边界。 根据 RFC 1341 的定义，封装（Boundary）边界是由两个连字符（“–”）后跟 Content-Type Header 中的 boundary 值组成的分隔线。它用于分隔 HTTP 请求体中的各个部分（即，子请求体）。 来看一个实际的案例，Web 浏览器请求包含两个 Part。通常情况下，Content-Type Header 信息如下： https://springdoc.cn/spring-bulk-batch-api-implementation/ Sat, 15 Jun 2024 09:36:02 +0800 https://springdoc.cn/spring-bulk-batch-api-implementation/ 1、概览 尽管标准的 REST API 可以满足大多数常见需求，但在处理批量（Bulk）或批处理（Batch）操作时，基于 REST 的架构风格存在一些限制。 本文将带你了解如何在微服务中应用 Bulk 和 Batch 操作，以及如何实现一些自定义的面向 “写” 的 Bulk 和 Batch API。 2、 Bulk 和 Batch API 简介 Bulk 和 Batch 操作这两个术语经常被互换使用。不过，两者之间还是有硬性区别的。 通常，Bulk（批量）操作是指对同一类型的多个条目执行相同的操作。一种简单的方法是为每个请求调用相同的 API 来执行批量操作。这种方法可能太慢，而且会浪费资源。相反，我们可以在一次往返中处理多个条目。 我们可以通过在一次调用中对同一类型的多个条目执行相同的操作来实现 Bulk（批量）操作。这种对条目集合进行操作的方式可减少整体延迟并提高应用性能。要实现 Bulk（批量）操作，我们可以重用用于于单个条目的现有端点，或者为 Bulk（批量）方法创建一个单独的路由。 Batch（批处理）操作通常是指对多个资源类型执行不同的操作。Batch API 是在一次调用中对多个资源执行多个操作的集合。这些资源操作可能没有任何连贯性。每个请求路由可以是独立的，互相之间没有依赖关系。 简而言之，“Batch” 一词是指批量处理不同的请求。 目前，对于实现 Bulk 或 Batch 操作来说，缺乏明确定义的标准或规范。此外，许多流行的框架，如 Spring，没有内置的 Bulk（批量）操作支持。 尽管如此，在本文中，我们将使用常见的 REST 架构来实现自定义 Bulk 和 Batch 操作的方法。 3、Spring 示例应用 假设我们需要构建一个简单的微服务，同时支持 Bulk 和 Batch 操作。 3.1、Maven 依赖 首先，添加 spring-boot-starter-web 和 spring-boot-starter-validation 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>3. https://springdoc.cn/spring-ai-rag-using-embedding-models-vector-databases/ Thu, 13 Jun 2024 11:40:29 +0800 https://springdoc.cn/spring-ai-rag-using-embedding-models-vector-databases/ 本文主要介绍以下内容： 嵌入式模型简介。 使用 DocumentReader 加载数据。 在 VectorStore 中存储 Embedding。 实现 RAG（Retrieval-Augmented Generation，检索增强生成），又名 Prompt Stuffing。 你可以在 GitHub 中找到本文的示例代码 大型语言模型（LLM），如 OpenAI、Azure Open AI、Google Vertex 等，都是在大型数据集上训练出来的。但这些模型并不是在你的私人数据上训练出来的，因此它们可能无法回答你所在领域的特定问题。但是，在你的私人数据上训练模型可能既昂贵又耗时。那么，我们该如何使用这些 LLM 来回答我们领域的特定问题呢？ 其中一种方法是使用 RAG（Retrieval-Augmented Generation，检索增强生成），又称 Prompt Stuffing（提示填充）。使用 RAG，从数据存储中检索相关文档，并将其传递给 LLM 以生成答案。在这一过程中，使用嵌入模型将文档转换为 Embedding，并将其存储到向量数据库中。 了解检索增强生成（RAG） 你可能在关系数据库中存储结构化数据，在 NoSQL 数据库中存储非结构化数据，甚至在文件中存储结构化数据。你能够使用 SQL 有效地查询关系数据库，使用 NoSQL 数据库的查询语言有效地查询 NoSQL 数据库。你还可以使用 Elasticsearch、Solr 等全文搜索引擎来查询非结构化数据。 不过，你可能希望使用具有语义的自然语言检索数据。 例如，“我喜欢 Java 编程语言” 和 “Java 始终是我的首选语言” 具有相同的语义，但使用了不同的词语。尝试使用准确的词语检索数据可能不会有效。 这就是 Embedding 的作用所在。Embedding 是单词、句子或文档的向量表示。你可以通过这些 Embedding，使用自然语言检索数据。 你可以将结构化和非结构化数据转换为 Embedding，并将其存储在向量数据库中。然后，你可以使用自然语言查询向量数据库并检索相关数据。然后，你可以通过相关数据查询 AI 模型，以获得响应。 检索增强生成（RAG）是在生成响应之前，通过使用训练数据之外的额外知识库来优化 LLM 输出的过程。 Embedding API Embedding API 可以将单词、句子、文档或图像转换为 Embedding 。Embedding 是单词、句子或文档的向量表示。 https://springdoc.cn/thymeleaf-layouts-using-fragment-expressions/ Thu, 13 Jun 2024 11:09:59 +0800 https://springdoc.cn/thymeleaf-layouts-using-fragment-expressions/ 在 Spring Boot + Thyemleaf 的应用中，我们可以使用 thymeleaf-layout-dialect 来定义网页的通用布局，效果很好。 但是当我们将 Spring Boot 应用编译到 GraalVM 原生镜像时，却 出现了问题。 GraalVM Native Image: Generating 'demo' (executable)... ======================================================================================================================== [1/7] Initializing... (5,6s @ 0,32GB) Version info: 'GraalVM 22.3.1 Java 17 CE' Java version info: '17.0.6+10-jvmci-22.3-b13' C compiler: gcc (linux, x86_64, 11.3.0) Garbage collector: Serial GC 2 user-specific feature(s) - com.oracle.svm.polyglot.groovy.GroovyIndyInterfaceFeature - org.springframework.aot.nativex.feature.PreComputeFieldFeature Field org.apache.commons.logging.LogAdapter#log4jSpiPresent set to true at build time Field org.apache.commons.logging.LogAdapter#log4jSlf4jProviderPresent set to true at build time Field org. https://springdoc.cn/jpa-criteriaquery-count-queries/ Wed, 12 Jun 2024 10:26:59 +0800 https://springdoc.cn/jpa-criteriaquery-count-queries/ 1、简介 Java Persistence API（JPA）是一种广泛使用的规范，用于访问、持久化和管理 Java 对象与关系数据库之间的数据。JPA 应用中的一项常见任务是计算符合特定条件的实体数量。使用 JPA 提供的 CriteriaQuery API 可以高效地完成这项任务。 CriteriaQuery 的核心组件是 CriteriaBuilder 和 CriteriaQuery 接口。CriteriaBuilder 是创建各种查询元素（如 Predicate、表达式和 CriteriaQuery）的工厂。而，CriteriaQuery 代表一个查询对象，它封装了 select、filter 和 order 标准。 本文将带你了解 JPA 中的 COUNT 查询，学习如何利用 CriteriaQuery API 轻松高效地执行 COUNT 操作。 本文以一个简单的图书管理系统为例，介绍如何利用 CriteriaQuery API 生成各种场景下的图书 COUNT 查询。 2、依赖 创建示例项目。 添加所需的 maven 依赖，包括 spring-data-jpa、spring-boot-starter-test 和 h2 内存数据库： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>runtime</scope> </dependency> 依赖添加完成后，创建图书管理系统示例。它允许我们执行各种查询，如统计所有图书，统计某个作者、书名和年份的图书的各种组合。 添加一个 Book （图书）实体，包含了 title、author、category 和 year 字段： https://springdoc.cn/hibernate-load-get-difference/ Wed, 12 Jun 2024 10:01:42 +0800 https://springdoc.cn/hibernate-load-get-difference/ 1、简介 在 Hibernate 中，load() 和 get() 是用于从数据库检索数据的两种方法。本文将带你了解这两种方法之间的区别。 2、加载策略 Hibernate 中的 load() 方法采用了一种懒加载策略。调用该方法时，它会返回一个实体的代理对象，延迟数据库查询，直到访问对象的属性或方法时才执行查询。 如下： Person person = new Person("John Doe", 30); Session session = sessionFactory.getCurrentSession(); session.saveOrUpdate(person); Person entity = session.load(Person.class, person.getId()); assertNotNull(entity); assertEquals(person.getName(), entity.getName()); assertEquals(person.getAge(), entity.getAge()); 首先，创建一个新的 Person 对象并将其保存到数据库中。然后，使用 load() 根据 id 检索 Person 实体。虽然实体看起来是一个 Person 对象，但它只是 Hibernate 提供的一个代理对象。 当访问代理对象的属性（如 name 和 age）时，Hibernate 会拦截调用，并在必要时从数据库动态加载实际数据。相反，get()方法采用了急切加载策略，会立即查询数据库并返回实际实体对象： Person entity = session.get(Person.class, person.getId()); assertNotNull(entity); assertEquals(person.getName(), entity.getName()); assertEquals(person.getAge(), entity.getAge()); 3、数据存在时 当调用 load() 方法时，Hibernate 会用提供的主键 id 创建一个实体的代理对象。这个代理对象是实体数据的占位符，只填充了 id。实体的其余属性未初始化，将在首次访问时从数据库加载。如果试图在未初始化代理对象的情况下访问它的任何属性，就会抛出 LazyInitializationException 异常： https://springdoc.cn/spring-authentication-single-page-application-pkce/ Mon, 10 Jun 2024 18:54:36 +0800 https://springdoc.cn/spring-authentication-single-page-application-pkce/ 1、简介 本文将带你了解如何在 OAuth 2.0 公开客户端（Public Client）中使用 Proof Key for Code Exchange （代码交换证明密钥，PKCE）。 2、背景 OAuth 2.0 公开客户端（如 SPA 单页应用，或使用授权码授权的移动应用）很容易受到授权码拦截攻击。如果客户端与服务器之间的通信是通过不安全的网络进行的，恶意攻击者就可能从授权端点截获授权代码。 如果攻击者可以访问授权码，就可以利用它获 Access Token。一旦攻击者拥有了 Access Token，就可以像合法应用用户一样访问受保护的应用资源，从而严重损害应用。例如，如果 Access Token 与金融应用相关联，攻击者就可能获取敏感的应用信息。 2.1、OAuth 授权码拦截攻击 来看看 Oauth 授权码拦截攻击是如何发生的： 上图展示了恶意攻击者如何滥用授权码获取 Access Token 的流程： 合法的 OAuth 应用使用其 Web 浏览器启动 OAuth 授权请求流程，并提供所有必要的详细信息。 Web 浏览器向授权服务器发送请求。 授权服务器向 Web 浏览器返回授权码。 在此阶段，如果通信是通过不安全的通道进行的，恶意用户可能会获取授权码。 恶意用户使用授权码从授权服务器获取 Access Token。 由于授权许可有效，授权服务器会向恶意应用签发 Access Token。恶意应用可以滥用 Access Token，代表合法应用访问受保护的资源。 代码交换证明密钥（Proof Key for Code Exchange，PKCE）是 OAuth 框架的一个扩展，旨在减轻这种攻击。 3、PKCE 和 OAuth PKCE（Proof Key for Code Exchange）扩展在 OAuth 授权码授权流程中包括以下额外步骤： https://springdoc.cn/spring-data-jpa-enums/ Thu, 06 Jun 2024 11:03:52 +0800 https://springdoc.cn/spring-data-jpa-enums/ 1、概览 在使用 Spring Data JPA 构建持久层时，经常要处理带有枚举字段的实体。这些枚举字段代表一组固定的常量，例如订单的状态、用户的角色或业务的某个阶段。 本文将带你了解如何使用标准的 JPA 方法和原生查询来查询实体类中声明的枚举字段。 2、应用设置 2.1、数据模型 首先，定义数据模型，包括一个枚举字段。 我们示例中的中心实体是 Article 类，它声明了一个枚举字段 ArticleStage，用于表示文章可能处于的不同阶段： public enum ArticleStage { TODO, IN_PROGRESS, PUBLISHED; } ArticleStage 枚举包含三个可能的阶段，代表文章从最初创建到最终发布的生命周期。 接下来，创建声明了 ArticleStage 枚举字段的 Article 实体类： @Entity @Table(name = "articles") public class Article { @Id private UUID id; private String title; private String author; @Enumerated(EnumType.STRING) private ArticleStage stage; // 构造函数/Getter/Setter 方法省略 } 我们将 Article 实体类映射到 articles 数据库表。此外，还使用 @Enumerated 注解指定 stage 字段应作为字符串在数据库中持久化。 2.2、Repository 层 定义好数据模型后，就可以创建一个继承了 JpaRepository 的 Repository 接口，以便与数据库交互： https://springdoc.cn/revisiting-spring-s-circular-dependencies/ Thu, 06 Jun 2024 10:12:33 +0800 https://springdoc.cn/revisiting-spring-s-circular-dependencies/ 一、循环依赖 1.1、什么是循环依赖 首先，什么是循环依赖？这个其实好理解，就是两个 Bean 互相依赖，类似下面这样： @Service public class AService { @Autowired BService bService; } @Service public class BService { @Autowired AService aService; } AService 和 BService 互相依赖： 这个应该很好理解。 1.2、循环依赖的类型 一般来说，循环依赖有三种不同的形态，上面 1.1 小节是其中一种。 另外两种分别是三者依赖，如下图： 这种循环依赖一般隐藏比较深，不易发觉。 还有自我依赖，如下图： 一般来说，如果我们的代码中出现了循环依赖，则说明我们的代码在设计的过程中可能存在问题，我们应该尽量避免循环依赖的发生。不过一旦发生了循环依赖，Spring 默认也帮我们处理好了，当然这并不能说明循环依赖这种代码就没问题。实际上在目前最新版的 Spring 中，循环依赖是要额外开启的，如果不额外配置，发生了循环依赖就直接报错了。 另外，Spring 并不能处理所有的循环依赖，后面会和大家进行分析。 二、循环依赖解决思路 2.1、解决思路 那么对于循环依赖该如何解决呢？其实很简单，加入一个缓存就可以了。 来看下面这张图： 如上图所示，引入了一个缓存池。 当我们需要创建 AService 的实例的时候，会首先通过 Java 反射创建出来一个原始的 AService，这个原始 AService 可以简单理解为刚刚 new 出来（实际是刚刚通过反射创建出来）还没设置任何属性的 AService，此时，我们把这个 AService 先存入到一个缓存池中。 接下来我们就需要给 AService 的属性设置值了，同时还要处理 AService 的依赖，这时我们发现 AService 依赖 BService，那么就去创建 BService 对象，结果创建 BService 的时候，发现 BService 依赖 AService，那么此时就先从缓存池中取出来 AService 先用着，然后继续 BService 创建的后续流程，直到 BService 创建完成后，将之赋值给 AService，此时 AService 和 BService 就都创建完成了。 https://springdoc.cn/java-get-path-resource-jar/ Tue, 04 Jun 2024 13:46:15 +0800 https://springdoc.cn/java-get-path-resource-jar/ 1、简介 在 Java 中，通常使用相对于 JAR 文件根目录的路径来访问JAR文件中的资源。 本文将带你了解获取 Java JAR 文件中资源路径的不同方法。 2、使用 Class.getResource() 方法获取资源的 URL Class.getResource() 方法提供了一种获取 JAR 文件中资源 URL 的直接方法。 该方法使用如下： @Test public void givenFile_whenClassUsed_thenGetResourcePath() { URL resourceUrl = GetPathToResourceUnitTest.class.getResource("/myFile.txt"); assertNotNull(resourceUrl); } 如上，调用 GetPathToResourceUnitTest.class 上的 getResource() 方法，并将资源文件路径 "/myFile.txt" 作为参数传递进去。然后，断言获取的 resourceUrl 不为 null，表示成功定位到资源文件。 3、使用 ClassLoader.getResource() 方法 还可以使用 ClassLoader.getResource() 方法访问 JAR 文件中的资源。在编译时不知道资源路径的情况下，该方法非常有用： @Test public void givenFile_whenClassLoaderUsed_thenGetResourcePath() { URL resourceUrl = GetPathToResourceUnitTest.class.getClassLoader().getResource("myFile.txt"); assertNotNull(resourceUrl); } 如上，使用类加载器 GetPathToResourceUnitTest.class.getClassLoader() 来获取资源文件。与前一种方法不同，该方法不依赖于类的包结构，它会在类路径的根级别搜索资源文件。 这意味着，无论资源位于项目结构中的哪个位置，它都能找到资源，从而更灵活地访问位于类包之外的资源。 4、Class.getResource() 和 ClassLoader.getResource() 的区别 Java 中的 Class. https://springdoc.cn/spring-boot-autowire-multiple-implementations/ Tue, 04 Jun 2024 11:59:00 +0800 https://springdoc.cn/spring-boot-autowire-multiple-implementations/ 1、简介 本文将带你了解如何在 Spring Boot 中自动装配具有多个实现的接口，以及一些常见用例。这是一个强大的功能，允许开发人员动态地将接口的不同实现注入到组件中。 2、默认行为 默认情况下，当接口存在多个实现并试图将该接口自动装配到组件中时，会遇到异常：“required a single bean, but X were found”。原因很简单： Spring 不知道我们想在该组件中注入哪个实现。幸运的是，Spring 提供了多种工具，可以明确要注入的实现。 3、@Qualifier 通过 @Qualifier 注解，我们可以在接口的多个实现组件中指定要自动装配的 Bean。我们可以将其应用到组件本身，为其自定义名称： @Service @Qualifier("goodServiceA-custom-name") public class GoodServiceA implements GoodService { // 实现 } 然后，用 @Qualifier 对参数进行注解，以指定想要的实现： @Autowired public SimpleQualifierController( @Qualifier("goodServiceA-custom-name") GoodService niceServiceA, @Qualifier("goodServiceB") GoodService niceServiceB, GoodService goodServiceC ) { this.goodServiceA = niceServiceA; this.goodServiceB = niceServiceB; this.goodServiceC = goodServiceC; } 如上，使用自定义 Qualifier 自动装配了 GoodServiceA。 而，GoodServiceB 实现却没有自定义 Qualifier： @Service public class GoodServiceB implements GoodService { // 实现 } 这种情况下，通过类名对组件进行了自动装配。这种自动装配的限定符（Qualifier）使用驼峰形式，例如，如果类名是 MyAwesomeClass，那么 myAwesomeClass 就是一个有效的限定符。 https://springdoc.cn/spring-mybatis-return-auto-generated-id/ Tue, 04 Jun 2024 11:01:41 +0800 https://springdoc.cn/spring-mybatis-return-auto-generated-id/ 1、概览 MyBatis 是一个开源 Java 持久层框架，可作为 JDBC 和 Hibernate 的替代品。它能简化持久层的代码，并自动封装结果集，开发者只需专注于编写自定义 SQL 查询或存储过程。 本文将带你了解如何在 Spring 中使用 MyBatis 插入（INSERT）数据时返回自动生成的 ID。 2、依赖设置 首先在 pom.xml 中添加 mybatis-spring-boot-starter 依赖： <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>3.0.3</version> </dependency> 3、示例 先创建一个简单的示例，在整个文章中都会用到。 3.1、定义实体 首先，创建一个代表汽车的简单实体类 Car： public class Car { private Long id; private String model; // Getter / Setter 方法省略 } 其次，定义一条创建表的 SQL 语句，并将其放入 car-schema.sql 文件中： CREATE TABLE IF NOT EXISTS CAR ( ID INTEGER PRIMARY KEY AUTO_INCREMENT, MODEL VARCHAR(100) NOT NULL ); 如上，ID 列是自增自主键（AUTO_INCREMENT）。 https://springdoc.cn/sbom-support-in-spring-boot-3-3/ Wed, 29 May 2024 16:25:15 +0800 https://springdoc.cn/sbom-support-in-spring-boot-3-3/ Spring Boot 3.3.0 已经发布，其中包含对 SBOM 的支持。SBOM 是 “Software Bill of Materials”（软件物料清单）的缩写，描述了用于构建软件构件的组件。在本文中，这些组件就是你的 Spring Boot 应用。SBOM 非常有用，因为它们准确地描述了你的应用包含的内容。有了这些信息，你可以评估安全漏洞是否影响你的应用，或者使用自动化安全工具扫描你的应用程序并提醒你存在的安全漏洞。 目前有多种 SBOM 格式，使用最广泛的是 CycloneDX、SPDX 和 Syft。Spring Boot 3.3.0 开箱即支持 CycloneDX。这种支持包括以下三个方面： 配置 CycloneDX 插件，以便在构建应用时生成 SBOM。 将生成的 SBOM 文件打包到 uber jar 中。 Actuator 端点，用于显示生成的 SBOM（如果启用）。 来看看如何进行实际操作： 首先，在 start.springboot.io 上生成一个新项目（确保选择 Spring Boot 3.3.0），并添加以下依赖： Spring Web Actuator 然后，在 IDE 中打开生成的项目，如果使用的是 Gradle，将以下内容添加到你的 build.gradle 文件中： plugins { id 'org.cyclonedx.bom' version '1.8.2' } 这将在构建中应用 CycloneDX Gradle plugin。Spring Boot 会检测到这一点，并负责插件的配置，你无需再做任何更改。 如果使用的是 Maven，则在 pom.xml 中加入以下内容： https://springdoc.cn/spring-jpa-converter-exception/ Wed, 29 May 2024 15:39:34 +0800 https://springdoc.cn/spring-jpa-converter-exception/ 1、概览 在使用 Spring Data JPA 时，我们经常会利用派生和自定义查询，以我们喜欢的格式返回结果。一个典型的例子就是 DTO 投影，它提供了一种只 SELECT 某些特定列以减少不必要数据开销的好方法。 然而，DTO 投影并不总是那么容易，如果实现不当，可能会导致 ConverterNotFoundException 异常。本文将带你了解 ConverterNotFoundException 异常出现的原因，以及如何在使用 Spring Data JPA 时避免 ConverterNotFoundException 异常。 2、在实践中理解异常 通过一个实际例子来理解异常。 为了简单起见，使用 H2 数据库。首先，在 pom.xml 文件中添加其依赖： <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.2.224</version> </dependency> 2.1、H2 配置 Spring Boot 提供了对 H2 嵌入式数据库的支持。默认情况下，它会配置应用使用用户名 sa 和空密码连接到 H2。 将数据库连接凭证添加到 application.properties 文件中： spring.datasource.url=jdbc:h2:mem:mydb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password= 如上就是使用 Spring Boot 设置 H2 配置所需的全部内容。 2.2、Entity 类 们定义一个 JPA 实体类 Employee： @Entity public class Employee { @Id private int id; @Column private String firstName; @Column private String lastName; @Column private double salary; // Getter/Setter 方法省略 } 如上，员工类（Employee）定义了 id、firstName、lastName 和 salary 属性。 https://springdoc.cn/java-openai-api-client/ Wed, 29 May 2024 12:56:57 +0800 https://springdoc.cn/java-openai-api-client/ 1、概览 随着生成式 AI 和 ChatGPT 的广泛应用，许多语言都开始提供与 OpenAI API 交互的库。Java 也不例外。 本文将带你了解 openai-java 库，它是一个开源的 OpenAI API 客户端，可以很方便地与 OpenAI API 通信。 2、依赖 首先，导入项目所需的 依赖，以下这三个模块专门用于交互的不同方面： <dependency> <groupId>com.theokanning.openai-gpt3-java</groupId> <artifactId>service</artifactId> <version>0.18.2</version> </dependency> <dependency> <groupId>com.theokanning.openai-gpt3-java</groupId> <artifactId>api</artifactId> <version>0.18.2</version> </dependency> <dependency> <groupId>com.theokanning.openai-gpt3-java</groupId> <artifactId>client</artifactId> <version>0.18.2</version> </dependency> 请注意，依赖名称中明确提到了 GPT3，但它 也适用于 GPT4。 3、Baeldung 辅导员 接下来，我们要构建一个工具，尝试根据我们最喜欢的学习平台上的文章和教程来创建课程表。虽然互联网为我们提供了无限的资源，我们几乎可以在线找到任何东西，但筛选信息却很困难。 4. OpenAI API Token 第一步是将应用连接到 OpenAI API。为此，需要提供一个 OpenAI Token，该 Token 可在 OpenAI 网站 上生成： 注意，要小心保存你的 Token，避免暴露它。为此，openai-java 示例使用了环境变量。这可能不是用于生产的最佳解决方案，但在小型实验中完全可行。 在运行时，不一定需要为机器配置环境变量；大多数 IDE 都支持在运行时为应用单独设置环境变量，例如 IntelliJ IDEA。 我们可以生成两种 Token：个人（Personal）和服务账户（Service Account）。个人 Token 不言自明。服务账户 Token 用于连接到 OpenAI 项目的机器人或应用。虽然两者都可以使用，但对于我们的目的来说，个人 Token 已经足够了。 https://springdoc.cn/spring-boot-3-3-available-now/ Fri, 24 May 2024 09:36:49 +0800 https://springdoc.cn/spring-boot-3-3-available-now/ 从 Spring Boot 3.2 进行升级 Jersey Observability（可观察性） Micrometer 1.13 已放弃对 Jersey 的支持，转而使用 Jersey 的 jersey-micrometer 模块。如果你的应用使用 Jersey 指标，请在升级时添加对 org.glassfish.jersey.ext:jersey-micrometer 依赖。 为了支持 Jersey 的可观察下，MetricsApplicationEventListener 已被替换为 ObservationApplicationEventListener。如果你之前使用 JerseyTagsProvider 自定义标签（Tag），现在需要实现一个 JerseyObservationConvention bean 来完成此功能。 删除了 Dropwizard 指标的 Dependency Management Dropwizard Metrics 的 Dependency management 理已删除。Spring Boot 并不直接依赖于 Dropwizard Metrics，因此不需要特定的版本。如果你的应用直接依赖于 Dropwizard Metrics，请更新你的构建配置，以指定满足其需求的版本。 Prometheus Client 1.x Spring Boot 3.3 包含对 Prometheus 客户端 1.x 的支持。该版本的客户端包含一些破坏性更改，例如对导出指标名称的更改。在 Prometheus 维护者添加该支持之前，1.x 客户端不支持使用 Prometheus Push Gateway。 如果你想继续使用 0.x 版本的 Prometheus 客户端，请从依赖中移除 io.micrometer:micrometer-registry-prometheus，并添加 io. https://springdoc.cn/spring-boot-prometheus/ Thu, 23 May 2024 10:37:17 +0800 https://springdoc.cn/spring-boot-prometheus/ 1、概览 在软件开发这个要求严苛的领域中，确保应用在在部署到生产环境后能够以最佳性能和可靠性运行是至关重要的。 本文将带你了解如何在 Spring Boot 应该中整合 Prometheus，以及如何通过基本配置和复杂配置丰富我们的监控策略。 2、Prometheus 是什么？ Prometheus 是一个开源项目，旨在深入挖掘我们的应用程序数据，通过创建过滤层来收集和分析从最简单到最复杂的所有内容。它不仅仅关乎数字和图表，而且通过其高级查询语言和时间序列数据能力，帮助我们理解应用程序的运行状况。 集成 Prometheus 使我们能够在问题发生之前就发现问题，对系统进行微调，确保应用程序以最佳性能运行，最终为用户带来更好的体验 - 方便、快捷、可靠。 3、开始在 Spring Boot 中使用 Prometheus 将 Prometheus 与 Spring Boot 应用程序整合后，就能以 Prometheus 可以理解和抓取的格式公开应用指标，从而有效地进行监控。这一过程包括两个主要步骤：向项目添加必要的依赖项，以及配置应用以公开指标。 3.1、添加依赖 首先，将 Spring Boot Actuator 和 Micrometer Prometheus Registry 添加到项目的依赖中。Actuator 提供了一系列内置端点，用于显示运行应用的性能信息，如健康状况、指标等。Micrometer Prometheus registry 会将这些指标格式化为 Prometheus 可读格式。 将依赖添加到 Maven 项目的 pom.xml 文件中： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> <dependency> <groupId>io.micrometer</groupId> <artifactId>micrometer-registry-prometheus</artifactId> </dependency> 如果使用的是 Gradle，则应在 build.gradle 文件中添加如下内容： implementation 'org.springframework.boot:spring-boot-starter-actuator' implementation 'io.micrometer:micrometer-registry-prometheus' 3.2、配置应用 添加依赖后，下一步就是配置 Spring Boot 应用，使其暴露 Prometheus 指标端点。这需要更新项目中的 application. https://springdoc.cn/hibernate-clear-managed-entities/ Thu, 23 May 2024 10:13:17 +0800 https://springdoc.cn/hibernate-clear-managed-entities/ 1、概览 本文将带你了解 JPA 是如何托管实体的，以及 Persistence Context（持久化上下文）由于外部变化而无法返回最新数据的情况。 2、Persistence Context 每个 EntityManager 都与一个 Persistence Context 相关联，该上下文在内存中存储所管理的实体。每当通过 EntityManager 对实体执行任何数据操作时，该实体就会变成由 Persistence Context 管理的实体。 当再次检索实体时，JPA 会从 Persistence Context 返回托管实体，而不是从数据库中获取。这种缓存机制有助于提高性能，而无需从数据库中重复获取相同的数据。 Persistence Context 在 JPA 中也被称为一级（first-level，L1）缓存。 3、Demo 设置 首先，创建一个简单的实体类： @Entity @Table(name = "person") public class Person { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; private String name; // 构造函数、Getter、Setter 方法省略 } 接下来，创建一个 Person 实体并将其持久化到数据库中： EntityTransaction transaction = entityManager.getTransaction(); transaction.begin(); Person person = new Person(); person.setName("David Jones"); entityManager.persist(person); transaction. https://springdoc.cn/spring-security-6-3-0-available-now/ Wed, 22 May 2024 09:49:56 +0800 https://springdoc.cn/spring-security-6-3-0-available-now/ Spring Security 6.3.0 正式发布！ 6.3 版本带来了几个引人注目的特性，如下： 长期的 JDK 序列化向后兼容性 新的方法安全注解和功能 密码受损检查 支持 OAuth 2.0 令牌交换 该版本将包含在即将发布的 Spring Boot 3.3 GA 版本中。 ⭐ 新特性 为 OAuth2AuthorizedClientId 添加 Getter #13648 为 JwtDecoders 添加超时默认值 #14890 文档：添加了将 GrantedAuthorityDefaults 声明为基础架构 Bean 的提示 #15065 改进全局身份认证（Global Authentication）的日志记录 #14711 文档小修正 #15043 需要对使用 Kotlin DSL 的导入进行微小的文档更新 #14969 OAuth2 客户端身份认证文档不完整 #14982 校对 CasAuthenticationFilter 文档 #14883 将 “Spring Boot 2.x” 替换为 “Spring Boot” #14919 简化禁用 “application/x-www-form-urlencoded” 编码 Client ID 和 Secret#14859 支持为依赖方注册元素指定标识符 #14487 更新 6. https://springdoc.cn/jpa-inheritance-vs-composition/ Tue, 21 May 2024 11:26:15 +0800 https://springdoc.cn/jpa-inheritance-vs-composition/ 1、简介 继承（Inheritance）和组合（Composition）是面向对象编程（OOP）中的两个基本概念，我们也可以在 JPA 中利用它们进行数据建模。在 JPA 中，继承和组合都是对实体间关系进行建模的技术，但它们代表的是不同类型的关系。本文将带你了解这两种方法及其影响。 2、JPA 中的继承 继承是一种 “is-a” 关系，即子类继承超类的属性和行为。这允许子类从超类继承属性和方法，从而促进了代码的重用。JPA 提供了几种策略来模拟实体与其对应的数据库表之间的继承关系。 2.1、单表继承（STI） 单表继承（Single Table Inheritance，STI）将所有子类映射到单个数据库表中。通过利用 区分列 来区分子类实例，这简化了 Schema 管理和查询执行过程。 首先，使用 @Entity 注解将 Employee 实体类定义为超类。接下来，将继承策略设置为 InheritanceType.SINGLE_TABLE，这样所有子类都会映射到同一个数据库表*。 然后，使用 @DiscriminatorColumn 注解来指定 Employee 类中的 区分列。该列用于区分单个表中不同类型的实体。 示例如下，使用 name = "employee_type" 将列名称指定为 employee_type，并使用 discriminatorType = DiscriminatorType.STRING 表示列包含字符串值： @Entity @Inheritance(strategy = InheritanceType.SINGLE_TABLE) @DiscriminatorColumn(name = "employee_type", discriminatorType = DiscriminatorType.STRING) public class Employee { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; // Get / Set 方法省略 } 对于每个子类，使用 @DiscriminatorValue 注解来指定与该子类相对应的 区别列 的值。在本例中，我们使用 manager 和 developer 分别作为 Manager 和 Developer 子类的 区别值： https://springdoc.cn/jpa-save-child-objects-automatically/ Tue, 21 May 2024 10:39:47 +0800 https://springdoc.cn/jpa-save-child-objects-automatically/ 1、概览 本文将带你了解 JPA 如何自动保存复杂的实体模型（即由父实体和子实体元素组成的复杂模型）以及常见的问题。 2、缺失关系注解 我们可能会忽略的第一件事就是添加关系注解。 创建一个子实体： @Entity public class BidirectionalChild { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; //Get/Set 方法省略 } 创建一个包含 List<BidirectionalChild> 的父实体： @Entity public class ParentWithoutSpecifiedRelationship { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; private List<BidirectionalChild> bidirectionalChildren; //Get/Set 方法省略 } 如上，bidirectionalChildren 字段上没有注解。尝试用这些实体创建一个 EntityManagerFactory： @Test void givenParentWithMissedAnnotation_whenCreateEntityManagerFactory_thenPersistenceExceptionExceptionThrown() { PersistenceException exception = assertThrows(PersistenceException.class, () -> createEntityManagerFactory("jpa-savechildobjects-parent-without-relationship")); assertThat(exception) .hasMessage("Could not determine recommended JdbcType for Java type 'com.baeldung.BidirectionalChild'"); } 运行测试，出现了异常，无法确定子实体的 JdbcType。单向和双向关系都会出现类似的异常，其根本原因是父实体中缺失 @OneToMany 注解。 https://springdoc.cn/spring-boot-formatting-json-dates/ Sat, 18 May 2024 10:05:19 +0800 https://springdoc.cn/spring-boot-formatting-json-dates/ 1、概览 本文将带你了解如何在 Spring Boot 应用中格式化 JSON Date 字段。 Spring Boot 默认使用 Jackson 作为 JSON 的序列化/反序列化框架。 2、在 Date 字段上使用 @JsonFormat 2.1、设置格式化 我们可以使用 @JsonFormat 注解来格式化特定字段： public class Contact { // 其他字段 @JsonFormat(pattern="yyyy-MM-dd") private LocalDate birthday; @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss") private LocalDateTime lastUpdate; // getter/setter 方法省略 } 如上，用了 Java 8 的日期类型，它在处理时间类型时非常方便。birthday 字段只显示日期，而 lastUpdate 字段则包括了时间。 当然，如果需要使用 java.util.Date 等传统类型，也可以同样的方式使用注解： public class ContactWithJavaUtilDate { // 其他字段 @JsonFormat(pattern="yyyy-MM-dd") private Date birthday; @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss") private Date lastUpdate; // getter/setter 方法省略 } 最后，来看看使用 @JsonFormat 格式化日期字段后的输出： https://springdoc.cn/java-sql-mybatis-log-sql-queries/ Fri, 17 May 2024 13:17:43 +0800 https://springdoc.cn/java-sql-mybatis-log-sql-queries/ 1、概览 MyBatis 是 Java 界流行的持久化框架，它通过将 SQL 查询映射到 Java 方法来简化数据库操作。 在使用 MyBatis 开发应用时，查看正在执行的 SQL 查询通常对调试很有用，本文将带你了解如何在 MyBatis 中将 SQL 查询日志输出到控制台。 2、支持的日志实现 MyBatis 是一个灵活的框架，可以与各种日志框架集成，包括 SLF4J、Apache Commons Logging、Log4j 2 和 JDK Logging。本文主要关注 Stdout （标准输出，即控制台）日志和 SLF4J。 Stdout 日志在本地功能开发过程中非常有用，它提供了一种简单的调试方法。而 SLF4J 更适合生产应用，它提供了更高级的抽象，可与其他的日志框架无缝集成。 3、在 MyBatis 中配置 Stdout 日志 使用 stdout 记录 MyBatis SQL，可以直接在控制台上查看执行的 SQL 语句。这种方法在开发和调试过程中非常方便。 要启用 MyBatis SQL 的 stdout 日志，需要在应用的 mybatis-config 文件中添加日志设置： <configuration> <settings> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings> </configuration> 将 logImpl 属性配置为 STDOUT_LOGGING 后，MyBatis 将在执行 SQL 查询时输出原始 SQL 语句、查询参数和查询结果。输出通常包括执行的 SQL、绑定的参数和返回的结果集等详细信息： https://springdoc.cn/spring-ai-structured-output/ Tue, 14 May 2024 11:01:05 +0800 https://springdoc.cn/spring-ai-structured-output/ 科学处理事物的片段和碎片，并假设存在连续性，而艺术则只关注事物的连续性，假设存在片段和碎片。- 罗伯特·M·皮尔西格 LLM（大型语言模型）生成结构化输出的能力对于依赖于可靠解析输出值的下游应用非常重要。开发人员希望将 AI 模型的结果快速转化为数据类型，如 JSON、XML 或 Java 类，以便传递给应用中的其他函数和方法。 Spring AI Structured Output Converter（结构化输出转换器）有助于将 LLM 输出转换为结构化格式。如下图所示，这种方法围绕 LLM 文本补全端点进行操作： 使用通用的补全 API 从大型语言模型（LLM）生成结构化输出需要对输入和输出进行仔细处理。结构化输出转换器在 LLM 调用之前和之后发挥着关键作用，确保实现所需的输出结构。 在进行 LLM 调用之前，转换器会将格式指令附加到提示中，为模型提供明确的指导，以生成所需的输出结构。这些指令充当蓝图，使模型的响应符合指定的格式。 在 LLM 调用之后，转换器会获取模型的输出文本，并将其转换为结构化类型的实例。转换过程包括解析原始文本输出，并将其映射到相应的结构化数据表示，如 JSON、XML 或特定领域（Domain）的数据结构。 注意，AI 模型不能保证按要求返回结构化输出。它可能不理解提示，也可能无法按要求生成结构化输出。 TIP： 如果你不想深入了解 API 的细节，可以过下一段，直接看 “使用转换器 ”部分。 1、结构化输出 API StructuredOutputConverter 接口定义如下： public interface StructuredOutputConverter<T> extends Converter<String, T>, FormatProvider { } 它以目标结构化类型 T 为参数，结合了 Spring Converter<String, T> 接口和 FormatProvider 接口： public interface FormatProvider { String getFormat(); } 下图说明了通过结构化输出 API 组件的数据流程。 https://springdoc.cn/spring-boot-h2-jdbcsqlsyntaxerrorexception-table-not-found/ Tue, 14 May 2024 10:39:58 +0800 https://springdoc.cn/spring-boot-h2-jdbcsqlsyntaxerrorexception-table-not-found/ 1、简介 H2 是一个简单的轻量级内存数据库，Spring Boot 可以自动对其进行配置，使开发人员可以轻松测试数据访问逻辑。 通常情况下，org.h2.jdbc.JdbcSQLSyntaxErrorException 是用于表示与 SQL 语法相关的错误的异常。“Table not found” 表示 H2 无法找到指定的表。 本文将带你了解 H2 抛出 JdbcSQLSyntaxErrorException 异常的原因以及解决办法。 2、示例 既然知道了异常背后的根本原因，来看看如何重现异常。 2.1、H2 配置 Spring Boot 会配置应用使用用户名 sa 和空密码连接到可嵌入的数据库 H2。将这些属性添加到 application.properties 文件中： spring.datasource.url=jdbc:h2:mem:mydb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password= 现在，假设有一个名为 person 的表。在此，使用一个基本的 SQL 脚本为数据库添加数据。默认情况下，Spring Boot 会加载 data.sql 文件： INSERT INTO "person" VALUES (1, 'Abderrahim', 'Azhrioun'); INSERT INTO "person" VALUES (2, 'David', 'Smith'); INSERT INTO "person" VALUES (3, 'Jean', 'Anderson'); 2.2、对象关系映射 接下来，使用 JPA 注解将表 person 映射到一个实体。 https://springdoc.cn/a-very-simple-approach-to-springboot-unit-testing/ Tue, 14 May 2024 10:28:34 +0800 https://springdoc.cn/a-very-simple-approach-to-springboot-unit-testing/ 本文主要介绍了一种单元测试方法，力求零基础人员可以从本文中受到启发，可以搭建一套好用的单元测试环境，并能切实提高交付代码的质量。极简体现在除了 POM 依赖和单元测试类之外，其他什么都不需要引入，只需要一个本地能启动的 Spring Boot 项目。 1、POM依赖 Springboot版本: 2.6.6 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>3.12.4</version> </dependency> 2、单元测试类示例 主要有两种。 第一种，偏集成测试 需要启动项目，需要连接数据库、RPC 注册中心等。 主要注解：@SpringBootTest + @RunWith(SpringRunner.class) + @Transactional + @Resource + @SpyBean + @Test @SpringBootTest + @RunWith(SpringRunner.class) 启动了一套 Spring Boot 的测试环境； @Transactional 对于一些修改数据库的操作，会执行回滚，能测试执行 sql，但是又不会真正的修改测试库的数据； @Resource 主要引入被测试的类； @SpyBean Spring Boot 环境下 mock 依赖的 Bean，可以搭配 Mockito.doAnswer(...).when(xxServiceImpl).xxMethod(any()) Mock 特定方法的返回值； @Test 标识一个测试方法； TIP：对于打桩有这几个注解 @Mock @Spy @MockBean @SpyBean，每一个都有其对应的搭配，简单说 @Mock 和 @Spy 要搭配 @InjectMocks 去使用，@MockBean 和 @SpyBean 搭配 @SpringBootTest + @RunWith(SpringRunner. https://springdoc.cn/spring-jpa-sequence-nextval/ Sat, 11 May 2024 16:42:15 +0800 https://springdoc.cn/spring-jpa-sequence-nextval/ 1、简介 Sequence （序列）是用于生成唯一 ID 的数字生成器，可避免数据库中出现重复记录。Spring JPA 为大多数情况提供了自动处理序列的方法。不过，在某些特定情况下，我们可能需要在持久化实体之前手动检索下一个序列值。例如，在将订单（Order）详细信息保存到数据库之前，需要生成一个唯一的订单号。 本文将带你了解使用 Spring Data JPA 从数据库序列中获取下一个值的几种方法。 2、设置项目依赖 首先要在 Maven pom.xml 文件中添加 Spring Data JPA 和 PostgreSQL 驱动依赖，并在数据库中创建序列。 2.1、Maven 依赖 首先，在 pom.xml 中添加必要的依赖项： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.postgresql</groupId> <artifactId>postgresql</artifactId> <scope>runtime</scope> </dependency> 2.2、测试数据 下面是我们在运行测试用例之前用来准备数据库的 SQL 脚本，可以将该脚本保存为 .sql 文件，并将其放在项目的 src/test/resources 目录中： DROP SEQUENCE IF EXISTS my_sequence_name; CREATE SEQUENCE my_sequence_name START 1; 该命令创建一个从 1 开始的序列，每调用一次 NEXTVAL 就递增一次。 然后，在测试类中使用 @Sql 注解，并将 executionPhase 属性设置为 BEFORE_TEST_METHOD，以便在每个测试方法执行之前将测试数据插入数据库： @Sql(scripts = "/testsequence.sql", executionPhase = Sql. https://springdoc.cn/spring-webclient-exchange-vs-retrieve/ Sat, 11 May 2024 15:02:33 +0800 https://springdoc.cn/spring-webclient-exchange-vs-retrieve/ 1、概览 WebClient 是一个简化 HTTP 请求执行过程的接口。与 RestTemplate 不同，它是一个响应式非阻塞客户端，可以消费和操作 HTTP 响应。虽然它被设计为非阻塞型，但也可用于阻塞型场景。 本文将带你了解 WebClient 接口中的关键方法，包括 retrieve()、exchangeToMono() 和 exchangeToFlux()，以及它们之间的差异。 2、示例项目设置 首先，创建一个 Spring Boot 应用，在 pom.xml 中添加 spring-boot-starter-webflux 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> <version>3.2.4</version> </dependency> 该依赖提供了 WebClient 接口，用于执行 HTTP 请求。 另外，来看看 https://jsonplaceholder.typicode.com/users/1 请求的 GET 响应示例： { "id": 1, "name": "Leanne Graham", // ... } 创建一个名为 User 的 POJO 类： class User { private int id; private String name; // 构造函数、Getter、Setter 方法省略 } 来自 JSONPlaceholder API 的 JSON 响应将被反序列化并映射到 User 类的实例。 https://springdoc.cn/spring-boot-set-default-timezone/ Tue, 07 May 2024 11:56:04 +0800 https://springdoc.cn/spring-boot-set-default-timezone/ 1、概览 有时，我们希望能够指定应用使用的时区。我们可以通过几种不同的方法来实现这一目标。一种方法是在执行应用时使用 JVM 参数。另一种方法是在启动生命周期的不同阶段以编程式在代码中进行更改。 本文将带你了解在 Spring Boot 应用中设置默认时区的几种方法。 2、主要概念 TimeZone 的默认值基于运行 JVM 的机器的操作系统。我们可以： 通过使用 user.timezone 参数传递 JVM 参数，可以根据运行任务或 JAR 的不同情况，以不同的方式传递参数。 在程序中使用 Bean 生命周期配置选项（在创建 Bean 时/创建 Bean 前），甚至在类内执行过程中使用这些选项。 在 Spring Boot 应用中设置默认 TimeZone 会影响不同的组件，如日志的时间戳、调度程序（Scheduler）、JPA/Hibernate 时间戳等。这意味着我们选择在何处执行取决于何时需要它生效。例如，是希望在创建某个 Bean 时生效，还是在初始化 WebApplicationContext 后生效？ 精确地确定何时设置该值非常重要，因为这可能会导致不必要的应用行为。例如，警报服务可能会在时区更改生效前设置警报，从而导致警报在错误的时间启动。 在决定采用哪种方案之前，另一个需要考虑的因素是可测试性。使用 JVM 参数是比较简单的选择，但测试起来可能比较麻烦，也更容易出现错误。我们无法保证单元测试能以与生产部署相同的 JVM 参数运行。 3、设置 bootRun 任务的默认时区 如果使用 bootRun 任务运行应用，我们可以在命令行中使用 JVM 参数传递默认 TimeZone。 在这种情况下，我们设置的值从一开始执行就可用： mvn spring-boot:run -Dspring-boot.run.jvmArguments="-Duser.timezone=Europe/Athens" 4、在执行 JAR 时设置默认时区 与运行 bootRun 任务类似，我们可以在执行 JAR 文件时在命令行中传递默认的 TimeZone 值。 同样，我们设置的值在执行之初就可用： java -Duser.timezone=Europe/Athens -jar spring-core-4-0. https://springdoc.cn/java-security-unrecoverablekeyexception-resolve/ Tue, 07 May 2024 11:00:34 +0800 https://springdoc.cn/java-security-unrecoverablekeyexception-resolve/ 1、简介 本文将带你了解如 java.security.UnrecoverableKeyException 异常出现的原因以及如何解决该异常。 2、背景 在 Java 中，有一个 Keystore 的概念。它本质上是一个包含一些 secret 的文件。它可以包含证书链以及与之对应的私钥。由于证书只是一个带有公钥的 包装器，我们可以简单地说 Keystore 包含了一对非对称密钥。 通常，用密码（“password ”通 常也称为 “passphrase”）保护私钥是一种很好的做法。这不仅是 Java Keystore 的良好做法，也是网络安全的一般做法。实现这种保护的方法通常是使用对称密钥加密算法（如各种 AES 实例）对私钥和密码进行加密。 在这里对我们来说需要注意的是，Keystore 中的私钥可以使用密码进行加密，如上所述。这个特性并不是所有类型的 Keystore 都支持，例如，JKS Keystore 支持私钥密码保护，但 PKCS12 Keystore 不支持。在我们的示例中，我们需要密码保护功能，因此我们使用 JKS Keystore。 3、UnrecoverableKeyException java.security.UnrecoverableKeyException 通常发生在使用 KeyManagerFactory 时，特别是调用 init() 方法时。这是 JSSE 中的一个类，允许我们检索 KeyManager 实例。KeyManager 是一个接口，它代表了一个抽象概念，负责将我们作为客户端向对等方进行身份验证。 init() 方法需要两个参数 - 用于获取认证凭证的 Keystore 和用于私钥解密的密码。当 KeyManagerFactory 无法恢复证书链的私钥时，就会出现 java.security.UnrecoverableKeyException 异常。问题来了 - UnrecoverableKeyException 中的 “recover” 到底是什么意思？这意味着证书链的私钥无法用给定的密码解密。因此，java.security.UnrecoverableKeyException 最常见的原因是 Keystore 中的私钥密码错误。 总之，如果为 KeyManagerFactory 提供的私钥密码/口令不正确，那么 KeyManagerFactory 将无法解密密钥，因此会出现此异常。 https://springdoc.cn/spring-boot-security-autoconfiguration/ Mon, 06 May 2024 10:20:52 +0800 https://springdoc.cn/spring-boot-security-autoconfiguration/ 1、概览 本文将带你了解 Spring Boot 中 Spring Security 的自动配置、默认安全配置，以及如何在需要时禁用或自定义它。 2、默认的 Spring Security 设置 首先添加 security starter 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> 这包含初始/默认 Security 配置的 SecurityAutoConfiguration 类。 这里没有指定版本，因为项目使用了 spring-boot-starter-parent 作为 parent。 默认情况下，应用会启用身份验证，内容协商（Content Negotiation）用于确定应使用 basic 还是 formLogin。 有一些预定义的配置属性： spring.security.user.name= spring.security.user.password= 如果不使用预定义属性 spring.security.user.password 配置密码并启动应用，默认密码将随机生成并打印在控制台日志中： Using default security password: c8be15da-4489-4491-9dc6-fab3f91435c7 有关更多默认值，请参阅 Spring Boot 中文文档中的 属性配置。 3、禁用自动配置 要禁止 Security 自动配置并添加我们的自定义配置，需要排除 SecurityAutoConfiguration 自动配置类。 可以通过 @SpringBootApplication 注解中的 exclude 属性来实现： @SpringBootApplication(exclude = { SecurityAutoConfiguration.class }) public class SpringBootSecurityApplication { public static void main(String[] args) { SpringApplication. https://springdoc.cn/broken-changes-in-springs-security-7/ Mon, 29 Apr 2024 16:03:02 +0800 https://springdoc.cn/broken-changes-in-springs-security-7/ 虽然 Spring Security 7.0 尚未确定发布日期，但是我们还是需要提前做一些准备工作，因为在已知的信息中，在 Spring Security 7.0 中会有一大批大家熟悉的 API 被移除。这些 API 在 Spring Security 6 中已经处于废弃状态，但是还能用，但是到了 Spring Security 7.0，这些就被移除了，所以我们还是有必要来看看 Spring Security 7.0 中的一些比较典型的变化。 1、Lambda 配置 Lambda DSL 自 Spring Security 5.2 版本以来就存在，它允许使用 lambda 表达式配置 HTTP Security。 我们来看看使用 lambda 配置 HTTP 安全性与之前的配置风格相比有何差别： 使用 lambda 的配置 @Configuration @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http .authorizeHttpRequests(authorize -> authorize .requestMatchers("/blog/**").permitAll() .anyRequest().authenticated() ) .formLogin(formLogin -> formLogin .loginPage("/login") . https://springdoc.cn/spring-data-jpa-not-managed-type-exception/ Sat, 27 Apr 2024 11:02:50 +0800 https://springdoc.cn/spring-data-jpa-not-managed-type-exception/ 1、概览 使用 Spring Data JPA 时，应用启动出现异常。大致如下： org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'requestMappingHandlerAdapter' ... Caused by: java.lang.IllegalArgumentException: Not a managed type: ...OurEntity at org.hibernate.metamodel.internal.MetamodelImpl.managedType(MetamodelImpl.java:583) at org.hibernate.metamodel.internal.MetamodelImpl.managedType(MetamodelImpl.java:85) ... 大意是说，一些 Bean 创建失败了，导致应用启动失败。 根异常是 IllegalArgumentException：“Not a managed type”，本文将带你了解出现这个异常的原因，以及如何解决该异常。 2、缺少 @Entity 注解 出现这种异常的一个可能原因是，忘记使用 @Entity 注解来标记实体。 2.1、重现问题 假设有以下实体类： public class EntityWithoutAnnotation { @Id private Long id; } 及其对应的 Spring Data JPA repository： public interface EntityWithoutAnnotationRepository extends JpaRepository<EntityWithoutAnnotation, Long> { } 最后是 Application 启动类，它会扫描上面定义的所有类： @SpringBootApplication public class EntityWithoutAnnotationApplication { } 尝试使用此 Application 来启动 Spring Context： https://springdoc.cn/java-persistenceunit-persistencecontext-difference/ Sat, 27 Apr 2024 10:23:27 +0800 https://springdoc.cn/java-persistenceunit-persistencecontext-difference/ 1、概览 Persistence Context（持久化上下文）和 Persistence Unit（持久化单元）是 JPA 中的两个重要概念，用来管理应用中实体的生命周期。 本文将带你了解 JPA 中的 EntityManager（实体管理器） 的作用，以及 Persistence Context 和 Persistence Unit 的重要性和用例。 2、EntityManager 和 EntityManagerFactory 首先来看看 EntityManager 和 EntityManagerFactory 接口，它们在管理持久性（Persistence）、实体和数据库交互方面发挥着重要作用。 2.1、EntityManager EntityManager 是一个与 Persistence Context 交互的接口。它对实体执行 CRUD 操作、跟踪更改并确保在事务提交时与数据库同步。EntityManager 代表一个 Persistence Context，并在事务范围内运行。 2.2、EntityManagerFactory EntityManagerFactory 是一个创建 EntityManager 的接口，有效地发挥着工厂的作用。创建时，EntityManagerFactory 会与特定的 Persistence Unit 关联，从而创建 EntityManager 的实例。 3、PersistenceContext PersistenceContext 是一个短暂的、事务范围的上下文，用于管理实体的生命周期。它代表一组存储在内存中的 “托管实体”，是实体管理器的一级缓存。如果事务开始，就会创建持久化上下文，并最终在事务提交或回滚时关闭或清除。 持久化上下文会自动检测对托管实体所做的更改，并确保所有实体更改与持久化存储（Persistence Storage）同步。 我们可以使用 @PersistenceContext 注解定义持久化上下文（Persistence Context）的类型： @PersistenceContext private EntityManager entityManager; JPA 中有两种持久化上下文： TRANSACTION 和 EXTENDED。 首先，使用 @Entity 注解创建与 PRODUCT 表相对应的实体： https://springdoc.cn/spring-boot-loki-grafana-logging/ Thu, 25 Apr 2024 15:33:39 +0800 https://springdoc.cn/spring-boot-loki-grafana-logging/ 1、简介 Grafana 实验室受 Prometheus 的启发开发了开源日志聚合系统 Loki。该系统的目的是存储日志数据并编制索引，从而方便高效地查询和分析由不同应用和系统生成的日志。 本文将带你了解如何在 Spring Boot 中使用 Loki 收集和汇总日志，并使用 Grafana 显示日志。 2、运行 Loki 和 Grafana 服务 首先以 Docker 容器的方式启动 Loki 和 Grafana 服务，以便收集和观察日志。 在 docker-compose 文件中定义 Loki 和 Grafana 服务： version: "3" networks: loki: services: loki: image: grafana/loki:2.9.0 ports: - "3100:3100" command: -config.file=/etc/loki/local-config.yaml networks: - loki grafana: environment: - GF_PATHS_PROVISIONING=/etc/grafana/provisioning - GF_AUTH_ANONYMOUS_ENABLED=true - GF_AUTH_ANONYMOUS_ORG_ROLE=Admin entrypoint: - sh - -euc - | mkdir -p /etc/grafana/provisioning/datasources cat <<EOF > /etc/grafana/provisioning/datasources/ds. https://springdoc.cn/spring-rest-document-query-parameters/ Thu, 25 Apr 2024 14:11:21 +0800 https://springdoc.cn/spring-rest-document-query-parameters/ 1、概览 API 文档在团队开发中极其重要，特别是在 API 接口及其复杂的情况下，良好的 API 文档不仅能提升开发效率，还能显示产品的质量。如果一家公司的 API 文档写得马马虎虎，那么它的 API 也可能写得马马虎虎。 程序员都讨厌写自己文档和别人不写文档。 本文将带你了解如何使用 Spring REST Docs 自动地生成 API 文档。 2、API 接口 一个简单 API 如下： @RestController @RequestMapping("/books") public class BookController { private final BookService service; public BookController(BookService service) { this.service = service; } @GetMapping public List<Book> getBooks(@RequestParam(name = "page") Integer page) { return service.getBooks(page); } } 该 API 返回系统中的 Book 数据。不过，由于可用图书数量庞大，不可能一次性返回所有。所以给客户端提供了一个查询参数 page，用于控制数据分页。 而且，需要把该参数设置为必须参数（默认就是必须参数），避免客户端一次性请求过多数据。如果客户端未提交该查询参数，就会收到状态为 400 的错误提示。 3、文档 编写文档的通常方法是 “手写文档”，这意味着开发人员必须把同一件事写两遍。首先写代码，然后再写对应的文档。太麻烦！ 文档是一种相当正式的文件，其目标是清晰明了，并不需要太多花里胡哨的东西。因此，我们可以根据代码生成文档，这样就不用重复写同样的东西，而且所有的改动都会反映在文档中。 我们可以通过 Spring REST Docs 来生成 API 文档。不过，它不是从代码中生成文档，因为代码没有提供太多上下文，而是从测试中生成文档。这可以表达相当复杂的案例和示例。另一个好处是，如果测试失败，文档也不会生成。 https://springdoc.cn/spring-data-jpa-update-or-insert/ Wed, 24 Apr 2024 13:50:19 +0800 https://springdoc.cn/spring-data-jpa-update-or-insert/ 1、简介 在应用开发中，执行 “更新或插入” 操作（也称为 “upsert”）的需要是很常见的。这个操作涉及将新记录存入数据库表中，如果记录不存在，则插入新记录；如果记录已经存在，则更新现有记录。 本文将带你了解使用 Spring Data JPA 执行 “更新或插入” 操作的不同方法。 2、实体类 定义 CreditCard 实体类用于演示： @Entity @Table(name="credit_card") public class CreditCard { @Id @GeneratedValue(strategy= GenerationType.SEQUENCE, generator = "credit_card_id_seq") @SequenceGenerator(name = "credit_card_id_seq", sequenceName = "credit_card_id_seq", allocationSize = 1) private Long id; private String cardNumber; private String expiryDate; private Long customerId; // Get / Set 方法省略 } 3、实现 本文介绍三种不同的方法来实现 “更新或插入”。 3.1、使用 Repository 方法 使用从 CrudRepository 接口继承的 save(entity) 方法在 Repository 中编写一个带事务的 default 方法。 https://springdoc.cn/spring-boot-disable-cacheable-annotation/ Mon, 22 Apr 2024 18:14:46 +0800 https://springdoc.cn/spring-boot-disable-cacheable-annotation/ 1、简介 缓存是一种有效的策略，当执行结果在一段已知时间内没有变化时，可以避免重复执行逻辑，从而提高性能。 Spring Boot 提供了 @Cacheable 注解，可以在方法上定义该注解，它就会缓存方法的结果。在某些情况下，例如在测试环境中进行测试时，我们可能需要禁用缓存来观察某些修改后的行为。 本文将带你了解如何配置 Spring Boot 中的缓存，以及如何在需要时禁用缓存。 2、缓存配置 设置一个简单的用例，通过 ISBN（国际标准书号）查询图书评论，并在某个逻辑中使用 @Cacheable 对该方法返回的结果进行缓存。 实体类 BookReview 如下，它包含 bookRating、isbn 等信息： @Entity @Table(name="BOOK_REVIEWS") public class BookReview { @Id @GeneratedValue(strategy= GenerationType.SEQUENCE, generator = "book_reviews_reviews_id_seq") @SequenceGenerator(name = "book_reviews_reviews_id_seq", sequenceName = "book_reviews_reviews_id_seq", allocationSize = 1) private Long reviewsId; private String userId; private String isbn; private String bookRating; // Get / Set 方法省略 } 在 BookRepository 中添加一个简单的 findByIsbn() 方法，用于按 isbn 查询书评： public interface BookRepository extends JpaRepository<BookReview, Long> { List<BookReview> findByIsbn(String isbn); } BookReviewsLogic 类包含一个在 BookRepository 中调用 findByIsbn() 的方法。我们添加了 @Cacheable 注解，将指定 isbn 的结果缓存在 book_reviews 缓存中： https://springdoc.cn/psqlexception-fatal-sorry-too-many-clients-already-solution/ Mon, 22 Apr 2024 17:40:45 +0800 https://springdoc.cn/psqlexception-fatal-sorry-too-many-clients-already-solution/ 1、概览 当 PostgreSQL 服务器无法接受客户端应用的连接请求时，就会抛出 PostgreSQL PSQLException：FATAL: sorry, too many clients already 这个异常。 本文将带你了解如何解决以及防止这个异常。 2、理解问题 DB 服务器启动时的连接数有限。有时，连接会用完。因此，数据库服务器无法提供新的连接。这时，它就会抛出异常：FATAL: sorry, too many clients already。 首先，来了解一下这个问题是如何、何时以及为何出现的。假设有四个 Client 应用连接到 PostgreSQL 数据库： 大多数情况下，应用会在启动时创建数据库连接池。假设数据库管理员为 PostgreSQL 数据库服务器配置了最多 90 个连接。需要注意的是，数据库会保留一些连接供内部使用。实际可供客户端使用的连接数甚至更少。运维为每个客户端应用配置的连接池大小为 30。 现在，假设运维从 Client-1 开始依次启动 Client 应用。当 Client-4 试图启动时，由于 Client-1、Client-2 和 Client-3 已经创建并阻塞了 90 个连接。因此，当 Client-4 向数据库服务器请求出创建 30 个连接时，服务器拒绝了请求，并显示错误 “FATAL: sorry, too many clients already”。 当开发人员尝试使用 psql、psgAdmin、DBeaver 等数据库管理工具连接 PostgreSQL 服务器时，也会出现该错误。因为这些工具也会尝试获取与数据库的连接，如果连接不足，它们也可能遇到同样的错误。 3、排除故障 首先，通过在 PostgreSQL 数据库中运行查询来确定最大连接数： show max_connections 默认情况下，该值为 100，可以通过修改数据库配置文件 postgresql.conf 中的 max_connections 属性来 设置 它： https://springdoc.cn/path-matching-in-the-new-spring-security-version/ Mon, 22 Apr 2024 11:16:51 +0800 https://springdoc.cn/path-matching-in-the-new-spring-security-version/ Spring Security 是一个功能强大且可高度定制的安全框架，它提供了一套完整的解决方案，用于保护基于 Spring 的应用。在 Spring Security 中，路径匹配是权限控制的核心部分，它决定了哪些请求可以访问特定的资源。本文将带你详细了解 Spring Security 中的路径匹配策略，并提供相应的代码示例。 在旧版的 Spring Security 中，路径匹配方法有很多，但是新版 Spring Security 对这些方法进行了统一的封装，都是调用 requestMatchers 方法进行处理： public C requestMatchers(RequestMatcher... requestMatchers) { Assert.state(!this.anyRequestConfigured, "Can't configure requestMatchers after anyRequest"); return chainRequestMatchers(Arrays.asList(requestMatchers)); } requestMatchers 方法接收一个 RequestMatcher 类型的参数，RequestMatcher 是一个接口，这个接口是一个用来确定 HTTP 请求是否与给定的模式匹配的工具。这个接口提供了一种灵活的方式来定义请求的匹配规则，从而可以对不同的请求执行不同的安全策略。 所以在新版 Spring Security 中，不同的路径匹配分方案实际上就是不同的 RequestMatcher 的实现类。 1. AntPathRequestMatcher AntPathRequestMatcher 是 Spring 中最常用的请求匹配器之一，它使用 Ant 风格的路径模式来匹配请求的 URI。 1.1 什么是 Ant 风格的路径模式 Ant 风格的路径模式（Ant Path Matching）是一种用于资源定位的模式匹配规则，它源自 Apache Ant 这个 Java 构建工具。在 Ant 中，这种模式被用来指定文件系统中的文件和目录。由于其简单性和灵活性，Ant 风格的路径模式也被其他许多框架和应用程序所采用，包括 Spring Security。 https://springdoc.cn/java-convert-google-protocol-buffer-timestamp-localdate/ Sun, 21 Apr 2024 19:40:31 +0800 https://springdoc.cn/java-convert-google-protocol-buffer-timestamp-localdate/ 1、概览 Protocol Buffer (Protobuf) 是一种用于序列化结构化数据的二进制格式。它是由 Google 开发的，并且被广泛应用于跨平台和跨语言的数据通信。Protocol Buffer 使用简洁、高效的编码方案，可以将结构化数据定义为消息类型，并生成针对不同编程语言的数据访问代码。这使得在不同的系统之间传输和解析数据变得更加简单和高效。Protocol Buffer 具有广泛的支持，包括 Java、C++、Python、Golang 等编程语言。 Protobuf Timestamp 类型代表一个时间点，与任何特定时区无关。本文将带你了解如何把 Protobuf Timestamp 实例转换为 Java 的本地时间类型，如 LocalDate。 2、Maven 依赖 在 pom.xml 中添加 protobuf-java 依赖： <dependency> <groupId>com.google.protobuf</groupId> <artifactId>protobuf-java</artifactId> <version>4.26.1</version> </dependency> 该依赖提供了 Timestamp 和其他与 Protobuf 相关的类。 3、Timestamp 类 Protobuf Timestamp 类表示自 Unix 纪元以来的时间点。与时区或本地日历没有关系。 它表示的是某个时间点的秒数和纳秒数。下面是使用 Java Instant 对象计算当前时间戳的示例： Instant currentTimestamp = Instant.now(); Timestamp timestamp = Timestamp.newBuilder() .setSeconds(currentTimestamp.getEpochSecond()) .setNanos(currentTimestamp.getNano()) .build(); 如上，通过 Instant 对象计算时间戳。首先，创建一个 Instant 对象，表示给定点的日期和时间。然后，提取秒和纳秒，并将它们传递给 Timestamp 实例。 4、把 Timestamp 实例转换为 LocalDate 在将 Timestamp 转换为 LocalDate 时，必须考虑时区及其与 UTC 的相关偏移，以准确表示本地日期。要将 Timestamp 转换为 LocalDate，首先要创建一个具有特定秒和纳秒的 Timestamp 实例： https://springdoc.cn/spring-data-mongorepository-limit-skip/ Sun, 21 Apr 2024 18:22:35 +0800 https://springdoc.cn/spring-data-mongorepository-limit-skip/ 1、概览 Spring Data MongoDB 的 MongoRepository 接口提供了一种简单的方式与 MongoDB Collection 进行交互。 本文将带你了解如何在 MongoRepository 中使用 limit 和 skip。 2、初始设置 首先，创建一个名为 StudentRepository 的 Repository，用于存储 Student 信息： public interface StudentRepository extends MongoRepository<Student, String> {} 然后，向该 Repository 添加一些 Student 示例数据: @Before public void setUp() { Student student1 = new Student("A", "Abraham", 15L); Student student2 = new Student("B", "Usman", 30L); Student student3 = new Student("C", "David", 20L); Student student4 = new Student("D", "Tina", 45L); Student student5 = new Student("E", "Maria", 33L); studentList = Arrays. https://springdoc.cn/java-logback-xml-custom-location/ Sat, 20 Apr 2024 11:15:24 +0800 https://springdoc.cn/java-logback-xml-custom-location/ 1、概览 日志记录是任何软件应用的重要组件，用于监控、调试和维护系统的健康状况。在 Spring Boot 生态系统中，Logback 作为默认的日志记录框架，提供了灵活和强大的功能。虽然 Spring Boot 简化了应用的许多方面，但有时仍然需要通过 logback.xml 配置文件来配置 Logback 以满足特定要求。 本文将会带你了解如何在 Java、Spring Boot 应用中指定 logback.xml 配置文件的位置。 2、logback.xml logback.xml 文件是 Logback 的配置文件，用于定义日志记录规则、appender 和日志格式（log format）。 默认情况下，Logback 会在 classpath 根目录中搜索该文件。这意味着将 logback.xml 文件放在 Spring Boot 项目的 src/main/resources 目录中就足够了，因为 Logback 会在运行时自动检测到它。不过，在某些情况下，自定义其位置也是必要的。 3、指定 logback.xml 位置 3.1、使用 System Properties 如果 logback.xml 配置文件不在打包后的 Jar 中，可以使用 System Properties 指定其位置。例如，在运行 Spring Boot 应用时，可以使用 JVM 参数： java -Dlogback.configurationFile=/path/to/logback.xml -jar application.jar 命令 -Dlogback.configurationFile=/path/to/logback.xml 将系统属性 logback.configurationFile 设置为指定路径，指定 Logback 使用提供的配置文件。 3.2、编程式配置 logback. https://springdoc.cn/spring-webflux-intercept-request-add-headers/ Sat, 20 Apr 2024 10:25:52 +0800 https://springdoc.cn/spring-webflux-intercept-request-add-headers/ 1、概览 Filter（拦截器/过滤器）是 Spring 提供的一个机制，可以在 Controller 处理请求或向客户端返回响应之前拦截并处理请求。 本文将带你了解如何使用 WebFlux 拦截客户端请求以及如何添加自定义 Header。 2、Maven 依赖 添加 spring-boot-starter-webflux 响应式 Web 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> <version>3.1.5</version> </dependency> 3、拦截请求 Spring WebFlux Filter 可分为 WebFilter 和 HandlerFilterFunction 两类。可使用这些过滤器拦截 Web 请求，并添加新的自定义 Header 或修改现有 Header。 3.1、使用 WebFilter WebFilter 以链式拦截方式处理 Web 请求。WebFilter 在全局范围内生效，一旦启用，将拦截所有的请求和响应。 首先，定义基于注解的 Controller： @GetMapping(value= "/trace-annotated") public Mono<String> trace(@RequestHeader(name = "traceId") final String traceId) { return Mono.just("TraceId: ".concat(traceId)); } 然后，拦截 Web 请求，使用 TraceWebFilter 实现添加一个新的 Header traceId： @Component public class TraceWebFilter implements WebFilter { @Override public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) { exchange. https://springdoc.cn/spring-boot-3-2-5-available-now/ Fri, 19 Apr 2024 10:52:08 +0800 https://springdoc.cn/spring-boot-3-2-5-available-now/ 🐞 Bug 修复 BindValidationFailureAnalyzer 使用了错误的 target #40364 Log4j2LoggingSystem 通过一个永远不会被移除的 SpringEnvironmentPropertySource 污染 Log4j2 的环境 #40326 使用 Maven 时，配置 spring-boot.excludes 或 spring-boot-includes 用户属性会导致构建失败，提示：Cannot find default setter #40323 @ServletComponentScan 无法在模拟的 Web 环境中注册 Servlet 组件 #40321 在将 Log4j2 配置为使用单个 JVM 范围日志记录器上下文的情况下部署到 Tomcat 时，加载自定义的 deny-all 过滤器可能会导致 StackOverflowError 错误 #40312 Jetty 支持不设置虚拟线程名称 #40152 3.2.0 之后，当 Hibernate Scanner 未禁用时，可执行 JAR 应用的启动速度变慢 #40125 线程中断时，LaunchedClassLoader 可能会抛出 NoClassDefFoundError 错误 #40096 📔 文档 Producible 的 javadoc 中 @WriteOperation 和 @DeleteOperation 的链接文本有误 #40386 明确参数和构造函数绑定的要求 #40157 🔨 依赖升级 升级到 ActiveMQ 5. https://springdoc.cn/spring-test-disable-enablescheduling/ Fri, 19 Apr 2024 09:35:47 +0800 https://springdoc.cn/spring-test-disable-enablescheduling/ 1、简介 本文将带你了解如何测试启用了定时任务（@EnableScheduling）的 Spring 应用，以及如何在测试过程中禁用定时任务。 2、示例 首先来看一个示例，假设我们有一个系统，允许公司的代表向客户发送通知。其中一些通知是时间敏感的，应该立即发送，但有些通知应该等到下一个工作日再发送。因此，我们需要一个机制来定期尝试发送这些通知： public class DelayedNotificationScheduler { private NotificationService notificationService; @Scheduled(fixedDelayString = "${notification.send.out.delay}", initialDelayString = "${notification.send.out.initial.delay}") public void attemptSendingOutDelayedNotifications() { notificationService.sendOutDelayedNotifications(); } } attemptSendingOutDelayedNotifications() 方法上添加了 @Scheduled 注解。当 initialDelayString 配置的时间过去后，该方法将被首次调用。执行结束后，Spring 会在 fixedDelayString 参数配置的时间过后再次调用该方法。该方法本身将实际逻辑委托给了 NotificationService。 当然，我们还需要开启调度功能。为此，需要在 @Configuration 类上添加 @EnableScheduling 注解。 3、集成测试中定时任务的问题 首先，为通知应用编写一个基本的集成测试： @SpringBootTest( classes = { ApplicationConfig.class, SchedulerTestConfiguration.class }, properties = { "notification.send.out.delay: 10", "notification.send.out.initial.delay: 0" } ) public class DelayedNotificationSchedulerIntegrationTest { @Autowired private Clock testClock; @Autowired private NotificationRepository repository; @Autowired private DelayedNotificationScheduler scheduler; @Test public void whenTimeIsOverNotificationSendOutTime_thenItShouldBeSent() { ZonedDateTime fiveMinutesAgo = ZonedDateTime. https://springdoc.cn/spring-test-application-events/ Thu, 18 Apr 2024 11:50:50 +0800 https://springdoc.cn/spring-test-application-events/ 1、概览 本文将带你了解如何测试 Spring Application Event，以及如何使用 Spring Modulith 的测试库。 2、Application Event Spring 提供了 Application Event（观察者设计模式），允许组件在保持松散耦合的同时相互通信。我们可以使用 ApplicationEventPublisher Bean 发布内部事件，这些事件都是纯 Java 对象，所有已注册的监听器（Listener）都会收到通知。 例如，当成功创建 Order 时，OrderService 组件可以发布 OrderCompletedEvent： @Service public class OrderService { private final ApplicationEventPublisher eventPublisher; // 构造函数 public void placeOrder(String customerId, String... productIds) { Order order = new Order(customerId, Arrays.asList(productIds)); // 验证和下单的业务逻辑 OrderCompletedEvent event = new OrderCompletedEvent(savedOrder.id(), savedOrder.customerId(), savedOrder.timestamp()); eventPublisher.publishEvent(event); } } 把 OrderCompletedEvent 对象作为应用事件发布，不同模块中监听这些事件的组件会收到通知。 假设 LoyaltyPointsService 会对这些事件做出反应，以奖励下单客户积分。要实现这一点，可以使用 Spring 的 @EventListener 注解： https://springdoc.cn/spring-jpa-continue-txn-after-exception/ Thu, 18 Apr 2024 09:50:58 +0800 https://springdoc.cn/spring-jpa-continue-txn-after-exception/ 1、概览 JPA 中的事务机制是一个功能强大的工具，它通过提交所有更改或在出现异常时回滚更改来确保原子性和数据完整性。然而，在某些情况下，我们可能需要在遇到异常的情况下继续进行事务处理而不回滚数据更改。 2、出现异常后事务自动回滚 在事务中可能会出现两种主要的异常情况。 2.1、在 Service 层出现异常后回滚事务 我们可能遇到回滚（Rollback）的第一个地方是在 Service 层，外部异常可能会影响数据库更改。 让我们通过下面的示例更仔细地了解一下这种情况。首先，添加 InvoiceEntity，作为数据模型： @Entity @Table(uniqueConstraints = {@UniqueConstraint(columnNames = "serialNumber")}) public class InvoiceEntity { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Integer id; // 自增 ID private String serialNumber; // 序列号 private String description; // 说明 // Getter / Setter } 如上，包含了一个自增 ID、一个需要在整个系统中唯一的序列号和一个说明。 现在，创建负责发票事务操作的 InvoiceService： @Service public class InvoiceService { @Autowired private InvoiceRepository repository; @Transactional public void saveInvoice(InvoiceEntity invoice) { repository.save(invoice); sendNotification(); } private void sendNotification() { throw new NotificationSendingException("Notification sending is failed"); } } 在 saveInvoice() 方法中，我们添加了事务性保存发票（invoice）和发送相关通知的逻辑。但是，在发送通知的过程中，会抛出异常： https://springdoc.cn/spring-data-jpa-querying-jsonb-columns/ Wed, 17 Apr 2024 15:20:18 +0800 https://springdoc.cn/spring-data-jpa-querying-jsonb-columns/ 1、简介 Spring Data JPA 为与关系数据库交互提供了强大的抽象层。然而，传统的关系表可能并不适合存储复杂的、半结构化的数据，如产品详细信息或用户偏好。这就是 JSONB 数据类型的用武之地。 本文将带你学习使用 Spring Data JPA 查询 JSONB 列的各种方法。 2、JSONB 列 JSONB（JavaScript Object Notation for Databases）是一种数据类型，专门用于在 PostgreSQL 等关系数据库中存储 JSON 数据。它允许我们在单列中使用键值对和嵌套对象来表示复杂的数据结构。通过 JPA Provider（如 Hibernate），Spring Data JPA 允许我们将这些 JSONB 列映射到实体类中的属性。 3、映射 JSONB 列 我们可以使用 @Column 注解的 columnDefinition 属性，在实体类中明确定义列类型： @Column(columnDefinition = "jsonb") private String attributes; 这种方法主要与 PostgreSQL 相关，因为 PostgreSQL 本身支持 jsonb 数据类型。通过在实体类的相应属性中添加此注解，我们就能为数据库提供所需列类型的提示。Spring Data JPA 通常会根据数据库列定义自动检测 jsonb 数据类型，因此在很多情况下，此注解是可选的。 4、设置项目依赖和测试数据 创建一个基本的 Spring Boot 项目，其中包含测试 JSONB 查询所需的依赖和测试数据。 4.1、项目设置 首先，在 Maven pom.xml 文件中添加必要的依赖： https://springdoc.cn/spring-transactional-async-annotation/ Sun, 14 Apr 2024 18:04:17 +0800 https://springdoc.cn/spring-transactional-async-annotation/ 1、简介 本文将带你了解 Spring 中 @Transactional 和 @Async 注解之间的兼容性。 2、 了解 @Transactional 和 @Async @Transactional 注解是 Spring 提供的声明式事务注解。可以让多个业务方法在同一个事务中执行，只有所有方法都正常执行完毕后事务才会提交。如果任何一个方法在调用过程中抛出了异常，那么事务就会回滚。 @Async 注解用于执行异步任务，如果从一个线程调用 @Async 方法或类，Spring 会使用另一个线程来运行该方法，从而提高执行效率。 在有些情况下，我们需要在代码中同时使用 @Transactional 和 @Async 来保业务数据的一致性以及性能。 3、@Transactional 能和 @Async 一起用吗？ 异步 和 事务 如果使用不当，可能会带来数据不一致等问题。 关于这一点，需要充分了解 Spring 的事务上下文和上下文之间的数据传播。 3.1、创建示例应用 本文使用银行的转账功能来说明事务和异步代码的使用。简而言之，是一个转账的场景，从一个账户中扣除资金并将其添加到另一个账户。 我们可以把它想象成数据库操作，比如 select 相关账户并 update 其资金余额： public void transfer(Long depositorId, Long favoredId, BigDecimal amount) { Account depositorAccount = accountRepository.findById(depositorId) .orElseThrow(IllegalArgumentException::new); Account favoredAccount = accountRepository.findById(favoredId) .orElseThrow(IllegalArgumentException::new); depositorAccount.setBalance(depositorAccount.getBalance().subtract(amount)); favoredAccount.setBalance(favoredAccount.getBalance().add(amount)); accountRepository.save(depositorAccount); accountRepository.save(favoredAccount); } 首先使用 findById() 查找相关账户，如果给定 ID 的账户不存在，则抛出 IllegalArgumentException 异常。 https://springdoc.cn/spring-boot-filter-response-body/ Sun, 14 Apr 2024 17:48:56 +0800 https://springdoc.cn/spring-boot-filter-response-body/ 1、简介 本文将带你了解如何在 Spring Boot Filter（过滤器）中获取 ServletResponse 的响应体。 2、场景 在使用 Spring Boot 中使用 Filter 时，从 ServletResponse 访问响应体非常麻烦。这是因为响应体不是随时可用的，它是在 Filter 链执行完毕后才写入输出流的。 但是，有些操作（如生成哈希签名）需要在发送给客户端之前读取完整的响应正文的内容。因此，需要找到读取响应体内容的方法。 3、使用 ContentCachingResponseWrapper 创建一个自定义 Filter，并使用 Spring 提供的 ContentCachingResponseWrapper 类进行包装： @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { ContentCachingResponseWrapper responseCacheWrapperObject = new ContentCachingResponseWrapper((HttpServletResponse) servletResponse); filterChain.doFilter(servletRequest, responseCacheWrapperObject); byte[] responseBody = responseCacheWrapperObject.getContentAsByteArray(); MessageDigest md5Digest = MessageDigest.getInstance("MD5"); byte[] md5Hash = md5Digest.digest(responseBody); String md5HashString = DatatypeConverter.printHexBinary(md5Hash); responseCacheWrapperObject.getResponse().setHeader("Response-Body-MD5", md5HashString); // ... } 简而言之，wrapper 类允许我们封装 HttpServletResponse 以缓存响应正文内容，并调用 doFilter() 将请求传递给下一个 Filter。 https://springdoc.cn/spring-boot-build-with-git-commit-id-maven-plugin/ Mon, 08 Apr 2024 09:44:09 +0800 https://springdoc.cn/spring-boot-build-with-git-commit-id-maven-plugin/ 原文地址：https://www.cnblogs.com/Naylor/p/18024689 简介 git-commit-id-maven-plugin 是一个maven 插件，用来在打包的时候将 git-commit 信息打进 Jar 中。 这样做的好处是可以将发布的某版本和对应的代码关联起来，方便查阅和线上项目的维护。至于它的作用，用官方说法，这个功能对于大型分布式项目来说是无价的。 功能 你是否经常遇到这样的问题： 测试提交了一个bug，开发人员无法确认是哪个版本有这个问题？当前测试环境部署的是某个版本吗？生产环境会不会也有这个问题？ 公司内部的项目，总共几十、几百个服务，每天都有服务的生产环境部署，一个服务甚至一天上线好几次，对于项目管理来说无法清晰了解某一时刻某个服务的版本 如何验证我的代码是否已经上线？ 。。。。。。 以上种种，都有一个共同的诉求，就是我希望在打包的时候将最后一次 git commit id 和当前 jar 关联起来并可试试查询 jar 对应的 git commit id 。 实践 引入插件 本例 Spring Boot 版本为 2.7.6，java 版本为 11 此插件已经上传到中央仓库（https://central.sonatype.com/artifact/io.github.git-commit-id/git-commit-id-maven-plugin?smo=true） 在项目pom.xml 中引入如下插件 <project> ...... <build> <plugins> <!-- git-commit-id-maven-plugin ：打包的时候携带git提交信息 --> <plugin> <groupId>io.github.git-commit-id</groupId> <artifactId>git-commit-id-maven-plugin</artifactId> <version>5.0.0</version> <executions> <execution> <id>get-the-git-infos</id> <goals> <goal>revision</goal> </goals> <phase>initialize</phase> </execution> </executions> <configuration> <generateGitPropertiesFile>true</generateGitPropertiesFile> <generateGitPropertiesFilename>${project.build.outputDirectory}/git.</generateGitPropertiesFilename> <includeOnlyProperties> <includeOnlyProperty>^git.build.(time|version)$</includeOnlyProperty> <includeOnlyProperty>^git.commit.id.(abbrev|full)$</includeOnlyProperty> </includeOnlyProperties> <format>txt</format> <commitIdGenerationMode>full</commitIdGenerationMode> </configuration> </plugin> </plugins> </build> </project> generateGitPropertiesFilename：用于指定生成的 gitCommitInfo 存放到哪个位置，后缀可以任意指定，如果不指定将使用 format 的值 format：指定文件后缀，一般为 properties、json commitIdGenerationMode：记录完整信息，若 format 为 json，此值必须为 full 此外为了能成功打出 jar 包，还需要如下插件的配合： https://springdoc.cn/kafka-spring-boot-dynamically-manage-listeners/ Fri, 29 Mar 2024 11:39:57 +0800 https://springdoc.cn/kafka-spring-boot-dynamically-manage-listeners/ 1、概览 本文将带你了解如何在 Spring Boot 应用中动态地启动和停止 Kafka Listener。 2、依赖 首先，添加 spring-kafka 依赖： <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>3.1.2</version> </dependency> 3、配置 Kafka 消费者 生产者是向 Kafka Topic 发布（写入）事件的应用。 在本教程中，我们使用单元测试来模拟生产者向 Kafka Topic 发送事件。订阅 Topic 并处理事件流的消费者由应用中的 Listener（监听器）表示。该 Listener 被配置为处理来自 Kafka 的传入消息。 通过 KafkaConsumerConfig 类来配置 Kafka 消费者，其中包括 Kafka broker 的地址、消费者组 ID 以及 Key 和 Value 的反序列化器： @Bean public DefaultKafkaConsumerFactory<String, UserEvent> consumerFactory() { Map<String, Object> props = new HashMap<>(); props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers); props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class); props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class); props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest"); props.put(JsonDeserializer.TRUSTED_PACKAGES, "com.baeldung.spring.kafka.start.stop.consumer"); return new DefaultKafkaConsumerFactory<>(props, new StringDeserializer(), new JsonDeserializer<>(UserEvent. https://springdoc.cn/spring-security-sign-jwt-token/ Thu, 28 Mar 2024 15:59:23 +0800 https://springdoc.cn/spring-security-sign-jwt-token/ 1、概览 JSON Web Tokens（JWT）是用于保护无状态应用的事实上的标准。Spring Security 框架提供了集成 JWT 以保护 REST API 的方法。 本文将带你了解如何在 Spring Boot 应用中创建 SecretKey 实例来签发和验证 JWT。 2、项目设置 2.1、Maven 依赖 首先，在 pom.xml 中添加 spring-boot-starter-web、spring-boot-starter-security、spring-boot-starter-data-jpa 和 h2 数据库依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>3.2.3</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> <version>3.2.3</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <version>3.2.3</version> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.2.224</version> </dependency> Spring Boot Starter Web 提供了用于构建 REST API 的 API。Spring Boot Starter Security 用于提供身份认证和授权。h2 是一个内存数据库，方便快速开发。 然后，还要在 pom.xml 中添加 jjwt-api、jjwt-impl 和 jjwt-jackson 依赖： <dependency> <groupId>io. https://springdoc.cn/spring-prototype-bean-runtime-arguments/ Thu, 28 Mar 2024 15:19:15 +0800 https://springdoc.cn/spring-prototype-bean-runtime-arguments/ 1、概览 本文将带你了解如何在 Spring 中使用运行时参数创建一个 Prototype Scope Bean。 在 Spring 中，有许多不同的 Bean Scope，默认的 Scope 是 Singleton（单例）。Singleton Scope 的 Bean 将始终产生相同的对象。 如果每次都需要从容器中获得一个新实例，可以使用 Pototype Scope Bean。然而，在大多数情况下，如果我们想要从一个 Singleton Bean 实例化 Pototype Bean，或者将动态参数传递给 Pototype Bean，可能会遇到一些问题。 2、使用动态参数创建 Prototype Bean 有时，我们需要在每次初始化时将动态参数作为输入来初始化 Spring Bean。通过 Spring，可以使用多种方法为 Prototype Bean 分配不同的动态参数。 首先，创建一个 Prototype Bean Employee ： public class Employee { private String name; public Employee(String name) { this.name = name; } public void printName() { System.out.println(name); } } 为 Employee Prototype Bean 创建一个配置： https://springdoc.cn/spring-boot-enabling-virtual-threads/ Wed, 27 Mar 2024 14:22:16 +0800 https://springdoc.cn/spring-boot-enabling-virtual-threads/ 本文将带你了解什么是虚拟线程、虚拟线程是如何提高应用吞吐量的，以及如何为 Spring Boot 应用启用虚拟线程。 并发编程的演化 线程 总所周知，线程（Thread）是计算机中的最小执行单元，由操作系统直接进行调度，每个线程都有自己的执行路径和执行状态，可以独立地运行和并发执行多个任务。 线程是一种重量级的资源，线程的创建、销毁以及在多个线程之间切换都需要耗费 CPU 时间，一个系统可以同时创建、调度的线程数量有限。所以，现在应用基本上都会使用 线程池 来解决这个问题，通过池化线程，可以减少线程频繁 创建 和 销毁 的成本。 例如，Servlet 容器（Tomcat、Undertow、Jetty）的并发模型就是通过线程池，为每一个请求分配一个线程池中的线程进行处理。但是，一旦涉及到阻塞操作（IO、网络请求），当前线程就会被挂起进入等待状态，这个线程就不能去执行其他任务。这就导致了，使用传统线程池并发模型的服务器能同时处理的请求有限。 而，当代 Web 应用基本上都是 IO 密集形应用，请求中执行的业务往往涉及到与数据库进行交互、调用远程服务（Socket IO），本地磁盘文件读写等等，因此使用阻塞式线程是非常低效的。 异步非阻塞编程 为了解决传统线程在执行 IO 操作时由于阻塞导致的低效，于是，开始有了一种 响应式异步非阻塞 的编程模型。 在 Java 界，这类优秀的框架很多，如 Netty、WebFlux、Vert.x 等等。它们都提倡一个东西，那就是：异步非阻塞，只要是涉及到 IO、阻塞的地方，当前线程不会等待操作执行完毕，会立即返回去执行其他可执行的任务。这时候，就需要通过监听器（Listener），或者回调（Callback）来获得操作最终的执行结果。 以 Netty 为例，伪代码如下： Channel channel = ...; // 异步写入数据到 Socket channel.write("Hello").addListener(future -> { if(future.isSuccess()) { // 写入成功 } else { // 写入失败 } }); 其中 channel.write("Hello") 用于向 Socket 写入数据，这就是典型的阻塞操作，在传统阻塞式编程中，该方法就会阻塞，直到数据被完全写入到 Socket 中。但是，在 Netty 中，在 write 方法执行后线程就会立即返回一个 ChannelFuture 对象，不会等待写入完成，因此这个线程仍然可以继续执行其他可执行的任务。 https://springdoc.cn/spring-beans-dynamic-registration-properties/ Wed, 27 Mar 2024 13:44:15 +0800 https://springdoc.cn/spring-beans-dynamic-registration-properties/ 1、概览 本文将带你了解如何根据自定义属性动态注册 Bean。 主要是学习 BeanDefinitionRegistryPostProcessor 接口，以及如何使用它将 Bean 添加到 Application Context 中。 2、设置 创建一个简单的 Spring Boot 应用。 首先，定义一个要动态注册的 Bean。然后，提供一个属性来决定如何注册 Bean。最后，定义一个配置类，它将根据自定义属性注册 Bean。 2.1、依赖 添加 Maven 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> <version>3.2.3</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <version>3.2.3</version> <scope>test</scope> </dependency> 添加 spring-boot-starter 和 spring-boot-starter-test 依赖。 2.2、Bean 类 接下来，根据自定义 application properties 定义要注册的 ApiClient： public class ApiClient { private String name; private String url; private String key; // Getter、Setter 和构造函数 public String getConnectionProperties() { return "Connecting to " + name + " at " + url; } } 假设我们希望根据提供的属性使用这个 Bean 连接到不同的 API。我们不想为每个 API 创建类定义，而是希望动态地为每个 API 定义属性并注册该 Bean。 https://springdoc.cn/jpa-criteria-querydsl-differences/ Fri, 22 Mar 2024 17:40:32 +0800 https://springdoc.cn/jpa-criteria-querydsl-differences/ 1、概览 Querydsl 和 JPA Criteria 是在 Java 中构建类型安全查询的流行框架。它们都提供了以静态类型表达查询的方法，使编写与数据库交互的高效、可维护代码变得更容易。本文将从多个角度对它们进行比较。 2、设置 首先，设置依赖。在所有示例中，都使用 HyperSQL 数据库： <dependency> <groupId>org.hsqldb</groupId> <artifactId>hsqldb</artifactId> <version>2.7.1</version> </dependency> 添加 maven-processor-plugin，使用 JPAMetaModelEntityProcessor 和 JPAAnnotationProcessor 为框架生成元数据。配置如下： <plugin> <groupId>org.bsc.maven</groupId> <artifactId>maven-processor-plugin</artifactId> <version>5.0</version> <executions> <execution> <id>process</id> <goals> <goal>process</goal> </goals> <phase>generate-sources</phase> <configuration> <processors> <processor>org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor</processor> <processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor> </processors> </configuration> </execution> </executions> <dependencies> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-jpamodelgen</artifactId> <version>6.2.0.Final</version> </dependency> </dependencies> </plugin> <persistence-unit name="com.baeldung.querydsl.intro"> <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider> <properties> <property name="hibernate.connection.driver_class" value="org.hsqldb.jdbcDriver"/> <property name="hibernate.connection.url" value="jdbc:hsqldb:mem:test"/> <property name="hibernate.connection.username" value="sa"/> <property name="hibernate.connection.password" value=""/> <property name="hibernate.hbm2ddl.auto" value="update"/> <property name="hibernate. https://springdoc.cn/spring-two-level-cache/ Fri, 22 Mar 2024 16:38:41 +0800 https://springdoc.cn/spring-two-level-cache/ 1、概览 缓存数据意味着我们的应用无需访问速度较慢的存储层，从而提高了性能和响应速度。我们可以使用任何内存实现库（如 Caffeine）来实现缓存。 虽然这样做可以提高数据检索的性能，但如果应用部署在多个副本上，那么实例之间就无法共享缓存。为了解决这个问题，可以引入一个分布式缓存层，所有实例都可以访问它。 本文将带你了解如何在 Spring 中使用 Spring 的缓存支持（spring-cache）实现两级缓存，以及在本地缓存层缓存失效时如何调用分布式缓存层。 2、示例 Spring Boot 应用 创建一个简单的应用，调用数据库获取一些数据。 2.1、Maven 依赖 首先，添加 spring-boot-starter-web 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>3.1.5</version> </dependency> 2.2、实现 Service 实现一个 Spring Service，从 Repository 中获取数据。 首先，创建 Customer 实体类： public class Customer implements Serializable { private String id; private String name; private String email; // 标准 Getter / Setter } 然后，实现 CustomerService 类和 getCustomer 方法： @Service public class CustomerService { private final CustomerRepository customerRepository; public Customer getCustomer(String id) { return customerRepository. https://springdoc.cn/hello-java-22/ Wed, 20 Mar 2024 15:09:41 +0800 https://springdoc.cn/hello-java-22/ Java 22 是一个重大改进，我认为对于每个人来说都值得升级。其中包含了一些重要的最终发布功能，比如 Project Panama，以及许多更好的预览功能。我无法一一介绍，但我想简要介绍一些我最喜欢的功能。如果你也想尝试一下的话，代码在 这里（https://github.com/spring-tips/java22）。 我喜欢 Java 22，当然也喜欢 GraalVM，这两个版本今天都发布了！Java 当然是我们最喜欢的运行时和语言，而 GraalVM 则是一个高性能的 JDK 发行版，它支持其他语言并允许超前编译（AOT）（它们被称为 GraalVM 原生镜像）。GraalVM 包含新 Java 22 版本的所有功能，还有一些额外的实用工具，所以我一直建议下载此版本。我特别感兴趣的是 GraalVM 原生镜像功能。生成的二进制文件几乎可以立即启动，与 JRE 相比占用的内存也少得多。GraalVM 并不新鲜，但值得注意的是，Spring Boot 拥有一个强大的引擎，支持将 Spring Boot 应用转化为 GraalVM 原生镜像。 简介 我使用的是的 Java SDKMAN 包管理器。在运行 macOS 的苹果 Silicon 芯片上运行。 从 官网 下载安装 GraalVM Community Edition 的预发布版，GraalVM Community 是开源版本。（GraalVM 也有免费的商业版本，但不是开源的）。它允许你通过配置文件引导优化（PGO）等技术构建更快的本地镜像。 解压它，并使用 SDKMAN 命令行工具手动安装，如下所示： sdk install java 22.07-graalce $HOME/bin/graalvm-jdk-22+36.1/Contents/Home` 然后输入：sdk default java 22.07-graalce，打开了一个新的 shell。输入 javac --version 和 java --version 以及 native-image --version 来验证一切正常。 https://springdoc.cn/spring-autowire-bean-servlet-filter/ Wed, 20 Mar 2024 11:24:20 +0800 https://springdoc.cn/spring-autowire-bean-servlet-filter/ 1、简介 Servlet Filter（过滤器）为拦截和处理传入的请求提供了强大的机制。 本文将会带你了解在 Servlet Filter 中无缝获取 Spring Bean 的各种方法，这种需求在 Spring Web 应用中很常见。 2、Servlet Filter 中 @Autowired 的限制 Spring 的依赖注入机制 @Autowired，是一种方便的方式来将依赖注入到由 Spring 管理的组件中。但它无法与 Servlet Filter 完美配合。这是因为 Servlet Filter 是由 Servlet 容器初始化的，通常是在 Spring 的 ApplicationContext 完全加载和初始化之前 。 因此，当容器实例化 Servlet Filter 时 ，Spring Context 可能尚未可用，从而导致在尝试使用 @Autowired 注解时 ，依赖为 null 或未初始化。 3、项目设置 创建一个通用的 LoggingService，它将自动装配到 Filter 中： @Service public class LoggingService { private final Logger logger = LoggerFactory.getLogger(this.getClass()); public void log(String message,String url){ logger.info("Logging Request {} for URI : {}",message,url); } } 然后，创建 Filter，拦截传入的 HTTP 请求，并使用 LoggingService 依赖记录 HTTP 方法和 URI 的详细信息： https://springdoc.cn/spring-data-jpa-refresh-fetch-entity-after-save/ Wed, 20 Mar 2024 10:20:31 +0800 https://springdoc.cn/spring-data-jpa-refresh-fetch-entity-after-save/ 1、简介 Java Persistence API（JPA）是连接 Java 对象和关系数据库的桥梁，允许我们无缝地持久化和检索数据。本文将会带你了解各种策略和技术，以便在 JPA 中进行保存操作后有效地刷新（Refresh）和获取（Fetch）实体。 2、了解 Spring Data JPA 中的实体管理 在 Spring Data JPA 中 ，实体管理围绕 JpaRepository 接口展开，该接口是与数据库交互的主要机制。通过继承了 CrudRepository 的 JpaRepository 接口 ，Spring Data JPA 为实体的持久化、检索、更新和删除提供了一套强大的方法。 此外， Spring 容器会将实体管理器（EntityManager） 自动注入这些 repository 接口。该组件是嵌入 Spring Data JPA 的 JPA 基础架构的一个组成部分，可促进与底层持久化上下文（Persistence Context）的交互和 JPA 查询的执行。 2.1、Persistence Context JPA 中的一个关键组件是持久化上下文（Persistence Context）。把这个上下文想象成一个临时存放区，JPA 在这里管理检索或创建实体的状态。 它可以确保： 实体是唯一的： 在任何时候，上下文中都只存在一个具有特定主键的实体实例。 跟踪更改： 实体管理器（EntityManager）会跟踪上下文中对实体属性所做的任何修改。 保持数据一致性： 在事务处理期间，实体管理器会将上下文中的更改与底层数据库同步。 2.2、JPA 实体的生命周期 JPA 实体有四个不同的生命周期阶段： 瞬时（New）、托管（Managed）、删除（Removed）和游离（Detached）。 当我们使用实体的构造函数创建一个新实体实例时，它处于 “瞬时” 状态。我们可以通过检查实体的 ID（主键）是否为 null 来验证这一点： Order order = new Order(); if (order. https://springdoc.cn/go-for-java-springboot-developers/ Sat, 16 Mar 2024 17:36:10 +0800 https://springdoc.cn/go-for-java-springboot-developers/ 我使用 Java 很多年了，我非常喜欢 Java 及其生态系统。在 Java 生态系统中，Spring Boot 是我构建 Java 应用的首选框架。 前不久，我在一个项目中使用了 Golang，起初我对它的感觉褒贬不一。但用得越多，就越喜欢它。 每当我尝试学习一种新的语言或框架时，我都会尝试将新框架/语言的概念映射到我已经熟悉的框架/语言中。这有助于我更快地理解新框架/语言的生态系统。 学习任何新知识的最好方法就是用它来构建一些东西。因此，在本文中，我将带你了解如何使用 Go 构建一个 REST API，包括配置管理、日志记录、数据库访问等各个方面。 本文并不会涉及到 Golang 的基础知识，如如何声明变量、循环、函数等。 使用的库 Go 没有类似 Spring Boot 的框架。通常，Go 开发人员喜欢使用标准库，只添加必要的库来构建应用。 本文将会使用到以下库来在 Go 中构建一个 REST API： Gin Web Framework - Web 框架 Viper - 配置库 zap - 日志库 pgx - Go 的 PostgreSQL 驱动程序和工具包 golang-migrate - 数据迁移 安装 Go 和工具 你可以从 https://go.dev/doc/install 下载并安装 Go。安装完成后，将 Go bin 目录添加到 PATH 环境变量中。 export GOPATH=$HOME/go export PATH="$PATH:$GOPATH/bin" 你可以使用 VS Code、IntelliJ IDEA Ultimate（使用 Go 插件）、GoLand 或任何其他 IDE 进行 Go 开发。 https://springdoc.cn/spring-data-3-crud-repository-interfaces/ Fri, 15 Mar 2024 15:12:35 +0800 https://springdoc.cn/spring-data-3-crud-repository-interfaces/ 1、概览 本文将带你了解 Spring Data 3 中引入的新 Repository 接口。 Spring Data 3 引入了基于 List 的 CRUD Repository 接口，可用于替换返回 Iterable 的现有 CRUD Repository 接口。此外，分页和排序接口默认不继承原始 CRUD Repository，而是由用户自己选择。接下来看看这些接口与现有接口有何不同，以及如何使用它们。 2、项目设置 首先创建一个 Spring Boot 应用，其中包含一个简单的实体和将使用新接口的 Repository。 2.1、依赖 首先，为项目添加所需的 spring-boot-starter-data-jpa 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <version>3.2.3</version> </dependency> 除此之外，还要配置数据库。可以使用任何 SQL 数据库，本文将使用 H2 内存数据库： <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> </dependency> 2.2、Entity 创建一个 Book 实体： @Entity public class Book { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String title; private String author; private String isbn; // 构造器、Getter、Setter } 有了实体后，来看看如何使用新接口与数据库交互。 https://springdoc.cn/microservices-with-spring-cloud-gateway-oauth2-and-keycloak/ Fri, 15 Mar 2024 12:12:54 +0800 https://springdoc.cn/microservices-with-spring-cloud-gateway-oauth2-and-keycloak/ 本文将带你了解如何使用 Keycloak 为 Spring Cloud Gateway 和 Spring Boot 微服务启用 OAuth2。本文是 上一篇文章 的扩展，并分析了 Spring Security 项目中提供的一些最新功能。 我们的架构由两个 Spring Boot 微服务组成、一个基于 Spring Cloud Gateway 的 API 网关和一个 Keycloak 授权服务器。Spring Cloud Gateway 在此充当 OAuth2 客户端和 OAuth2 资源服务器。对于任何传入请求，它都会在将流量转发到下游服务之前验证 Access Token。对于任何未经验证的请求，它都会使用 Keycloak 初始化一个授权码授权的流程。我们的方案需要包括内部微服务之间的通信。它们都隐藏在 API 网关后面。caller 应用调用 callme 应用暴露的端点。通信中使用的 HTTP 客户端必须使用网关发送的 Access Token。 源码 本文中的代码托管在 Github，你可以克隆这个 Repository，进入到 oauth 目录，其中包含了两个 Spring Boot 微服务：callme 和 caller。当然，还有构建在 Spring Cloud Gateway 之上的 gateway 应用。之后，只需按照说明操作即可。 运行并配置 Keycloak 我们以 Docker 容器的形式运行 Keycloak。默认情况下，Keycloak 在 8080 端口上公开 API 和 Web 控制台。还需要通过环境变量设置管理员用户名和密码。下面是运行 Keycloak 容器的命令： https://springdoc.cn/spring-cloud-gateway-oauth2-with-keycloak/ Fri, 15 Mar 2024 10:54:17 +0800 https://springdoc.cn/spring-cloud-gateway-oauth2-with-keycloak/ Spring Cloud Gateway 的 OAuth2 支持是微服务安全流程的关键部分。当然，使用 API 网关模式的主要原因是将服务隐藏起来，不对外部客户端可见。然而，在隐藏服务时，并没有对其进行安全保护。本文将带你了解如何使用 Spring Security 和 Keycloak 设置 Spring Cloud Gateway 的 OAuth2 功能。 源码 本文中的源码托管在 Github 上，你可以克隆 sample-spring-security-microservices 仓库，然后按照说明进行安装和部署即可。 在 Spring Cloud Gateway 中启用 OAuth2 要为 Spring Cloud Gateway 应用启用 OAuth2 支持，除了启用网关功能所必需的 spring-cloud-starter-gateway 依赖外，还需要添加 spring-boot-starter-oauth2-client 以启用 Spring Security 对 OAuth 2.0 授权框架和 OpenID Connect Core 1.0 的客户端支持，以及 spring-cloud-starter-security 来激活 TokenRelay Filter。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-oauth2-client</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-gateway</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-security</artifactId> </dependency> 接下来为 OAuth2 客户端提供配置设置。因为要与 Keycloak 集成，所以应将 registrationId 的名称（spring. https://springdoc.cn/java-jca-blowfish-implementation/ Thu, 14 Mar 2024 17:04:15 +0800 https://springdoc.cn/java-jca-blowfish-implementation/ 1、概览 Blowfish 加密算法最初是作为 DES 加密算法的替代方案而设计的，是当今最流行的加密算法之一。Blowfish 是一种对称的分组加密算法，由 Bruce Schneier 于 1993 年设计 。该算法的块大小为 64 位，密钥长度为 446 位，优于 DES 和 3DES 算法。 本文将带你了解如何使用 Java Cryptography Architecture（JCA）中提供的 Blowfish 算法实现加密和解密。 2、生成密钥 由于 Blowfish 是一种对称加密算法，它在加密和解密过程中使用相同的密钥。所以，接下来我们要创建一个密钥来加密文本。这个密钥应该被安全地保存，不应该在公共场合分享。 定义密钥： // 定义密钥 String secretKey = "MyKey123"; byte[] keyData = secretKey.getBytes(); //使用 Blowfish 算法创建 SecretKeySpec SecretKeySpec secretKeySpec = new SecretKeySpec(keyData, "Blowfish"); 接下来，就可以通过加密模式构建 Cipher 了： // 使用 Blowfish 算法创建 Cipher Cipher cipher = Cipher.getInstance("Blowfish"); 然后，使用加密模式（Cipher.ENCRYPT_MODE）初始化 cipher，并指定 Secret Key： // 使用 Secret Key 在加密模式下初始化 cipher cipher. https://springdoc.cn/spring-security-migrate-5-to-6/ Thu, 14 Mar 2024 10:38:22 +0800 https://springdoc.cn/spring-security-migrate-5-to-6/ 1、概览 Spring Security 6 有几处重大变化，包括删除了一些类和已废弃的方法，并引入了一些新方法。 从 Spring Security 5 迁移到 Spring Security 6 可以在不破坏现有代码的情况下逐步完成。此外，还可以使用 OpenRewrite 等第三方插件来促进向最新版本的迁移。 本文将带你了解如何把 Spring Security 5 的现有应用迁移到 Spring Security 6（替换过时的方法，并利用 Lambda DSL 简化配置。此外，还利用 OpenRewrite 加快迁移速度）。 2、Spring Security 和 Spring Boot 版本 Spring Boot 基于 Spring 框架，各版本的 Spring Boot 使用最新版本的 Spring 框架。Spring Boot 2 默认使用 Spring Security 5，而 Spring Boot 3 使用 Spring Security 6。 要在 Spring Boot 应用中使用 Spring Security，首先需要在 pom.xml 中添加 spring-boot-starter-security 依赖。 可以在 pom.xml 的 properties 部分 指定所需的版本，从而覆盖默认的 Spring Security 版本 ： https://springdoc.cn/kafka-offset-with-spring-boot/ Tue, 12 Mar 2024 17:08:31 +0800 https://springdoc.cn/kafka-offset-with-spring-boot/ 本文将带你了解如何使用 Spring Boot 和 Spring Kafka 管理 Kafka 消费者偏移量（Offset）。 在之的一篇文章中，主要说明了应用处理 Kafka 消息的方式可能会影响系统的整体性能，并没有考虑消费者端的消息重复或消息丢失等问题。本文将会介绍这些话题。 1、源码 本文中的源码托管在 GitHub，你可以克隆它到本地，然后按照说明中的步骤操作即可。 2、简介 在开始之前，首先要说明一些与使用 Spring Kafka 提交偏移量有关的重要事项。首先，默认情况下，Spring Kafka 会将消费者的 enable.auto.commit 属性设置为 false。这意味着提交偏移量的责任在于框架，而非 Kafka。当然，我们可以通过将该属性设置为 true 来改变默认行为。顺便说一句，这也是 Spring Kafka 2.3 之前的默认做法。 禁用了 Kafka 自动提交（Auto Commit）后，我们就可以利用 Spring Kafka 提供的 7 种不同的提交策略。本文不会分析所有策略，只分析最重要的几种。默认策略是 BATCH。为了设置不同的策略，需要覆盖 AckMode，例如在 Spring Boot application.properties 中设置 spring.kafka.listener.ack-mode 属性的值。 首先来看看 BATCH 模式。 3、Spring Boot Kafka 应用示例 为了测试使用 Spring Kafka 进行的偏移提交，我们将创建两个简单的应用：producer （生产者）和 consumer（消费者）。生产者向 Topic 发送规定数量的消息，而消费者接收并处理这些消息。下面是生产者 @RestController 的实现。它允许我们按需向 transactions Topic 发送指定数量的消息： @RestController public class TransactionsController { private static final Logger LOG = LoggerFactory . https://springdoc.cn/function-calling-in-java-and-spring-ai-using-the-latest-mistral-ai-api/ Fri, 08 Mar 2024 15:59:11 +0800 https://springdoc.cn/function-calling-in-java-and-spring-ai-using-the-latest-mistral-ai-api/ 领先的开源大型语言模型开发商 Mistral AI 宣布，其尖端模型新增了 函数调用 支持。 函数调用 是一种便于 LLM 与外部工具和 API 集成的功能。它使语言模型能够请求执行客户端函数，从而访问必要的运行时信息或动态执行任务。 本文将带你了解如何将 Mistral AI 的新函数调用功能与 Java 特别是 Spring AI 结合使用。 如果你对底层的 Java 客户端的详细细节不感兴趣，不想浪费时间，可以直接看 使用 Spring AI 调用函数 章节。 1、使用 Java 调用函数 如果你想使用 Java 和 Spring AI 测试最新的 Mistral AI 功能，你会发现 Mistral 不支持 Java 客户端，也还没有发布函数调用 API。 因此，我不得不通过探索他们的 JavaScript/Python 客户端来解决这个问题。下面是一个类图，说明了 API 的各个组件及其相互联系。 熟悉 OpenAI API 的人会注意到，Mistral AI 的新 API 几乎与 OpenAI API 相同，只有一些细微差别。不过，还有一个重要的限制： 在撰写本文时，Mistral AI 不支持并行函数调用，这使它与 OpenAI、Azure OpenAI 和 Vertex AI Gemini 提供的最新 LLM 模型有所不同。 https://springdoc.cn/junit-datajpatest-repository/ Fri, 08 Mar 2024 15:08:49 +0800 https://springdoc.cn/junit-datajpatest-repository/ 1、简介 在使用 Spring Data JPA 进行数据持久化的 Spring Boot 应用中，测试与数据库交互的 Repository 至关重要。 本文将带你了解如何使用 Spring Boot 提供的 @DataJpaTest 注解和 JUnit 对 Spring Data JPA Repository 进行有效地测试。 2、了解 @DataJpaTest 和 Repository 类 本节主要介绍在 Spring Boot 应用中，@DataJpaTest 和 Repository 之间的交互。 2.1、@DataJpaTest @DataJpaTest 注解用于测试 Spring Boot 应用中的 JPA Repository。它是一个专门的测试注解，为测试持久层提供了一个最小的 Spring Context。该注解可与 @RunWith 和 @SpringBootTest 等其他测试注解结合使用。 此外，@DataJpaTest 的范围仅限于应用的 JPA Repository 层。它不会加载整个 Application Context，从而使测试更快、更集中。此注解还为测试 JPA 实体提供了预配置的 EntityManager 和 TestEntityManager。 2.2、Repository 在 Spring Data JPA 中，Repository 是 JPA 实体之上的一个抽象层。它为执行 CRUD（创建、读取、更新、删除）操作和执行自定义查询提供了一组方法。这些 Repository 通常从 JpaRepository 等接口继承而来，负责处理与特定实体类型相关的数据库交互。 https://springdoc.cn/spring-data-jpa-skip-select-insert/ Fri, 08 Mar 2024 14:17:50 +0800 https://springdoc.cn/spring-data-jpa-skip-select-insert/ 1、概览 在某些情况下，当使用 Spring Data JPA Repository 保存实体时，可能会在日志中遇到额外的 SELECT。这可能会因大量额外调用而导致性能问题。 本文将带你了解如何在 Spring Data JPA 中执行 INSERT 时跳过 SELECT，以提高性能。 2、设置 在深入 Spring Data JPA 并对其进行测试之前，先要做一些准备工作。 2.1、依赖 为了创建测试 Repository，需要使用 Spring Data JPA 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> 使用 H2 数据库作为测试数据库： <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> </dependency> 使用 Spring Context 进行集成测试。添加 spring-boot-starter-test 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> 2.2、配置 本例中使用的 JPA 配置如下： spring.jpa.hibernate.dialect=org.hibernate.dialect.H2Dialect spring.jpa.hibernate.ddl-auto=create-drop spring.jpa.hibernate.show_sql=true spring.jpa.hibernate.hbm2ddl.auto=create-drop 如上，让 Hibernate 生成 schema，并将所有 SQL 查询记录到日志中。 3、导致 SELECT 查询的原因 首先，创建一个 Task 实体： https://springdoc.cn/spring-data-jpa-repository-view/ Fri, 08 Mar 2024 12:15:25 +0800 https://springdoc.cn/spring-data-jpa-repository-view/ 1、概览 数据库视图（Database View）是关系型数据库系统中的一种类似表的结构，其中的数据源来自一个或多个连接在一起的表。 Spring Data Repository 通常用于数据库表，但也可以有效地应用于数据库视图。本文将带你了解如何在 Spring Data JPA 中使用 Repository 从数据库视图检索数据。 2、数据库表设置 本文使用 H2 数据库系统进行数据定义，并使用 SHOP 和 SHOP_TRANSACTION 这两个示例表演示数据库视图概念。 SHOP 表存储商店信息： CREATE TABLE SHOP ( shop_id int AUTO_INCREMENT, shop_location varchar(100) NOT NULL UNIQUE, PRIMARY KEY(shop_id) ); SHOP_TRANSACTION 表存储与商店相关的交易记录，并通过 shop_id 对 SHOP 表进行引用： CREATE TABLE SHOP_TRANSACTION ( transaction_id bigint AUTO_INCREMENT, transaction_date date NOT NULL, shop_id int NOT NULL, amount decimal(8,2) NOT NULL, PRIMARY KEY(transaction_id), FOREIGN KEY(shop_id) REFERENCES SHOP(shop_id) ); 在实体-关系（ER）模型中，可以将其说明为 “一对多” 的关系，即一个商店可以有多笔交易。但是，每笔交易只与一家商店相关联。可以用 ER 图直观地表示这一点： https://springdoc.cn/spring-data-jpa-query-hints/ Fri, 08 Mar 2024 11:36:10 +0800 https://springdoc.cn/spring-data-jpa-query-hints/ 1、简介 本文将带你了解 Spring Data JPA 中 Query Hint （查询提示）的功能、基本原理以及如何有效地应用它们。 这些提示有助于优化数据库查询，并通过影响优化器的决策过程来改善应用性能。 2、理解 Query Hint Spring Data JPA 中的 Query Hint 是一种强大的工具，可帮助优化数据库查询并提高应用性能。与直接控制执行不同，Query Hint 会影响优化器（Optimizer）的决策过程。 在 Spring Data JPA 中，可以在 org.hibernate.annotations 包中找到这些 Hint，同时还有与 Hibernate 相关的各种注解和类。需要注意的是，这些 Hint 的解释和执行通常取决于底层持久化层实现（Persistence Provider），如 Hibernate 或 EclipseLink，因此它们是特定于厂商的。 3、使用 Query Hint Spring Data JPA 提供了多种利用 Query Hint 优化数据库查询的方法。 3.1、基于注解的配置 Spring Data JPA 提供了一种使用注解为 JPA 查询添加 Query Hint 的简便方法。通过 @QueryHints 注解，可以指定用于生成 SQL 查询的 JPA @QueryHint 数组。 示例如下，设置了 JDBC fetch size Hint，以限制结果返回的大小： https://springdoc.cn/spring-data-jpa-custom-database-functions/ Fri, 01 Mar 2024 17:31:20 +0800 https://springdoc.cn/spring-data-jpa-custom-database-functions/ 1、概览 数据库函数是数据库管理系统的重要组成部分，可将逻辑和执行封装在数据库中。它们有助于高效的数据处理和操作。 本文将带你了解在 Spring Boot 应用中使用 Spring Data JPA 调用自定义数据库函数的各种方法。 2、项目设置 为了简单，本文使用 H2 数据库。 首先在 pom.xml 中加入 Spring Boot Data JPA 和 H2 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <version>3.2.2</version> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.2.224</version> </dependency> 3、数据库函数 数据库函数是通过在数据库中执行一组 SQL 语句或操作来执行特定任务的数据库对象。当逻辑是数据密集型的时候，这可以提高性能。虽然数据库函数和存储过程的操作类似，但它们也有不同之处。 3.1、函数与存储过程 虽然不同的数据库系统之间可能会有具体的差异，但它们之间的主要差异可归纳在下表中： 特点 数据库函数 存储过程 执行 可在查询中调用 必须明确调用 返回值 始终返回一个值 可返回无值、单值或多值 参数 仅支持输入参数 支持输入和输出参数 调用 无法使用函数调用存储过程 可使用存储过程调用函数 用途 通常执行计算或数据转换 通常用于复杂的业务逻辑 3.2、H2 函数 为了说明如何从 JPA 调用数据库函数，我们将创建一个在 H2 数据库中的数据库函数来说明如何从 JPA 中调用它。 H2 数据库函数只是一个嵌入的 Java 源代码，它将被编译和执行： https://springdoc.cn/spring-data-jpa-findby-multiple-columns/ Fri, 01 Mar 2024 17:07:51 +0800 https://springdoc.cn/spring-data-jpa-findby-multiple-columns/ 1、简介 Spring Data JPA 提供了查询推导功能（派生查询），只需遵循方法名称约定就能自动推导出查询。 本文将带你了解如何使用查询推到功能，通过一列或多列查找实体。 2、设置 定义一个 Account 实体，其中包含与用户账户相关的属性： @Entity @Table(name = "ACCOUNTS") public class Account { @Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "accounts_seq") @SequenceGenerator(name = "accounts_seq", sequenceName = "accounts_seq", allocationSize = 1) @Column(name = "user_id") private int userId; private String username; private String password; private String email; private Timestamp createdOn; private Timestamp lastLogin; @OneToOne @JoinColumn(name = "permissions_id") private Permission permission; // getter / setter } 为了演示，在 ACCOUNTS 表中添加一些示例数据： https://springdoc.cn/java-javatype-class-jackson/ Fri, 01 Mar 2024 16:48:18 +0800 https://springdoc.cn/java-javatype-class-jackson/ 1、简介 使用 Jackson 时，或多或少都会遇到需要从给定的类（Class）对象中生成 JavaType 的情况。 本文将带你了解如何借助 Jackson 库从类创建 JavaType。 2、JavaType 和 Class 在了解详情之前，先来了解一下 JavaType 和 Class。 2.1、Java 中的 JavaType 在 Jackson 中，JavaType 类代表 Java 类型。它是一种机制，可以处理泛型和数组等通用类型。 创建 JavaType 实例非常重要，尤其是当我们在处理 JSON 时处理泛型结构。 2.2、Java 中的 Class 在 Java 中，Class 类是反射 API 的成员，在运行时用来表示类或接口。 此外，它还提供类的信息，包括名称、字段、方法和构造函数。 3、使用 TypeFactory 创建 JavaType 要使用 Jackson 从提供的 Class 对象生成 JavaType 实例，需要利用 TypeFactory 类。 TypeFactory 提供了一个默认实例，可以构建不同的类型，无论是泛型还是参数化类型。 以使用 TypeFactory 从泛型类生成 JavaType 对象为例： class MyGenericClass<T> { // Class 实现 } @Test void givenGenericClass_whenCreatingJavaType_thenJavaTypeNotNull() { Class<? https://springdoc.cn/java-spring-cloud-aws-v3-message-acknowledgement/ Fri, 01 Mar 2024 14:24:27 +0800 https://springdoc.cn/java-spring-cloud-aws-v3-message-acknowledgement/ 1、概览 消息确认是 MQ 系统中的一种标准机制，它向 Message Broker 发出信号，表明消息已被消费，不应再次传递。在亚马逊的 SQS（Simple Queue Servic）中，确认是通过删除队列中的信息来执行的。 本文将带你了解 Spring Cloud AWS SQS v3 中开箱即提供的三种确认模式： ON_SUCCESS、MANUAL 和 ALWAYS。 本文将利用 Spring Cloud AWS SQS V3 入门文章 中的环境和测试设置，使用事件驱动场景来说明用例。 2、依赖 首先，导入 Spring Cloud AWS BOM，以确保 pom.xml 中的所有依赖项相互兼容： <dependencyManagement> <dependencies> <dependency> <groupId>io.awspring.cloud</groupId> <artifactId>spring-cloud-aws</artifactId> <version>3.1.0</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> 还要添加 Core 和 SQS starter 依赖： <dependency> <groupId>io.awspring.cloud</groupId> <artifactId>spring-cloud-aws-starter-sqs</artifactId> </dependency> <dependency> <groupId>io.awspring.cloud</groupId> <artifactId>spring-cloud-aws-starter</artifactId> </dependency> 最后，添加测试所需的依赖，即带有 JUnit 5 的 LocalStack 和 TestContainers、用于验证异步消息消费的 awaitility 库，以及用于处理断言的 AssertJ： https://springdoc.cn/java-spring-cloud-aws-v3-intro/ Fri, 01 Mar 2024 14:06:06 +0800 https://springdoc.cn/java-spring-cloud-aws-v3-intro/ 1、概览 Spring Cloud AWS 是一个旨在简化与 AWS 服务交互的项目。SQS（Simple Queue Service）是 AWS 的一种解决方案，用于以可扩展的方式发送和接收异步消息。 本文将带你了解针对于 Spring Cloud AWS 3.0 完全重写的 Spring Cloud AWS SQS Integration。 该框架为处理 SQS 队列提供了熟悉的 Spring 抽象，如 SqsTemplate 和 @SqsListener 注解。 本文以一个事件驱动的场景为例，介绍了如何发送和接收消息。并展示使用 Testcontainers（一种管理一次性 Docker 容器的工具）和 LocalStack（可在本地模拟类似 AWS 的环境，用于测试）设置集成测试的策略。 2、依赖 Spring Cloud AWS BOM 可确保项目之间的版本兼容。它声明了包括 Spring Boot 在内的许多依赖项的版本。 添加 Spring Cloud AWS BOM 到 pom.xml： <dependencyManagement> <dependencies> <dependency> <groupId>io.awspring.cloud</groupId> <artifactId>spring-cloud-aws</artifactId> <version>3.0.4</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> 我们需要的主要依赖关系是 SQS Starter，它包含项目中所有与 SQS 相关的类。SQS Integration 不依赖于 Spring Boot，可在任何标准 Java 应用中独立使用： https://springdoc.cn/spring-boot-ssl-hot-reload-on-kubernetes/ Fri, 23 Feb 2024 15:57:40 +0800 https://springdoc.cn/spring-boot-ssl-hot-reload-on-kubernetes/ 本文将带你了解如何为在 Kubernetes 上运行的 Spring Boot 应用配置 SSL 证书的热重载。我们将使用 Spring Boot 3.1 和 3.2 版本中引入的两个功能。第一个功能允许我们利用 SSL Bundle 在服务器端和客户端配置和使用自定义 SSL 配置。第二个功能使得在 Spring Boot 应用的嵌入式 Web 服务器中轻松进行 SSL 证书和密钥的热重载。 为了在 Kubernetes 上生成 SSL 证书，我们将使用 cert-manager。“cert-manager” 可以在指定期限后轮换证书，并将其保存为 Kubernetes Secret。之前的文章中介绍了如何在 Secret 更新时自动重启 Pod 的类似方案。我们使用 Stakater Reloader 工具在新版本的 Secret 上自动重启 pod。不过，这次我们使用 Spring Boot 新特性来避免重新启动应用（Pod）。 源码 你也可以克隆我的源代码，亲自尝试一下。首先克隆我的 GitHub 仓库。然后切换到 ssl 目录。你会发现两个 Spring Boot 应用：secure-callme-bundle 和 secure-caller-bundle。之后，你只需按照说明操作即可。 工作原理 在介绍技术细节之前，首先来了解我们的应用架构和面临的挑战。我们需要设计一个解决方案，在 Kubernetes 上运行的服务之间实现 SSL/TLS 通信。这个解决方案必须考虑到证书重载的情况。此外，服务器和客户端必须同时进行重载，以避免通信中出现错误。在服务器端，使用嵌入式 Tomcat 服务器。在客户端应用中，使用 Spring RestTemplate 对象。 https://springdoc.cn/java-gson-prevent-expressing-integers-as-floats/ Fri, 23 Feb 2024 15:14:49 +0800 https://springdoc.cn/java-gson-prevent-expressing-integers-as-floats/ 1、简介 在将 Java 对象序列化和反序列化为 JSON 格式或从 JSON 格式反序列化 Java 对象时，Google 开发的 Gson 库是一个不错的选择。但是，在序列化对象时，我们通常会遇到 Gson 将整数显示为浮点数的问题。 本文将带你了解为什么在 Gson 的设计中整数被视为浮点数？以及如何解决这个问题。 2、问题的定义 Gson 可将 Java 对象序列化为 JSON。默认情况下，Gson 会将整数序列化为浮点数，以获得更精确的表示。下面是一个简单的例子： public String jsonString= "[{\"id\":4077395,\"field_id\":242566,\"body\":\"\"}, " + "{\"id\":4077398,\"field_id\":242569,\"body\":[[273019,0],[273020,1],[273021,0]]}, " + "{\"id\":4077399,\"field_id\":242570,\"body\":[[273022,0],[273023,1],[273024,0]]}]"; 如上，我们声明了一个名为 jsonString 的 JSON 字符串，它代表一个对象数组。这个 JSON 数组有不同的字段，如 id、field_id 和 body。 现在，我们使用 Gson 库将 JSON 字符串反序列化为 Hashtable<String, Object> 对象列表。 ArrayList<Hashtable<String, Object>> responses; Type ResponseList = new TypeToken<ArrayList<Hashtable<String, Object>>>() {}.getType(); responses = new Gson().fromJson(jsonString, ResponseList); 如上，我们声明了一个名为 responses 的 ArrayList，其中包含 Key 为字符串、Value 为对象的 Hashtable 类型元素。此外，我们还利用 Gson 库将 jsonString 反序列化为 Hashtables 列表。 https://springdoc.cn/spring-batch-itemreader-access-job-parameters/ Fri, 23 Feb 2024 14:25:26 +0800 https://springdoc.cn/spring-batch-itemreader-access-job-parameters/ 1、概览 Spring Batch 是一个强大的 Java 批处理框架，因此在数据处理活动和定时任务运行中被广泛选择。根据业务逻辑的复杂程度，作业可以依赖不同的配置值和动态参数。 本文将带你了解如何使用 JobParameter 以及如何从基本的批处理组件中访问它们。 2、Demo 项目 我们将为药房服务开发一个 Spring Batch。主要业务任务是查找即将过期的药品，根据销售情况计算新价格，并通知消费者即将过期的药品。此外，我们将从内存中的 H2 数据库读取数据，并将所有处理细节写入日志，以简化实现过程。 2.1、依赖 要开始演示应用，需要添加 Spring Batch 和 H2 依赖： <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.2.224</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-batch</artifactId> <version>3.2.0</version> </dependency> 可以在 Maven Central Repository 中找到最新的 H2 和 Spring Batch 版本。 2.2、准备测试数据 首先在 schema-all.sql 中定义 Schema： DROP TABLE medicine IF EXISTS; CREATE TABLE medicine ( med_id VARCHAR(36) PRIMARY KEY, name VARCHAR(30), type VARCHAR(30), expiration_date TIMESTAMP, original_price DECIMAL, sale_price DECIMAL ); 初始测试数据定义在 data. https://springdoc.cn/spring-hibernate-n1-problem/ Fri, 23 Feb 2024 11:47:25 +0800 https://springdoc.cn/spring-hibernate-n1-problem/ 1、概览 Spring JPA 和 Hibernate 为无缝数据库通信提供了强大的工具。不过，由于客户端将更多控制权委托给了框架，因此生成的查询可能远非最佳。 本文将带你了解使用 Spring JPA 和 Hibernate 时常见的 N+1 问题，以及可能导致该问题的不同情况。 2、社交媒体平台 为了更好地将问题形象化，我们需要概述实体之间的关系。以一个简单的社交网络平台为例。这里只有用户（User）和帖子（Post）： 我们在图表中使用了 Iterable，并且我们将为每个示例提供具体的实现：List 或 Set。 为了测试请求的数量，我们将使用一个专用库，而不是检查日志。不过，我们会参考日志，以便更好地了解请求的结构。 如果在每个示例中没有明确指定关系的获取类型（Fetch Type），则默认情况下假定为默认值。所有的一对一关系都使用急切加载（Eager Fetch），而一对多关系则使用延迟加载（Lazy）。此外，代码示例中使用了 Lombok 来减少代码中的冗余。 3、N+1 问题 N+1 问题指的是，对于单个请求（例如检索用户），会对每个用户发出额外请求，以获取其信息。虽然这个问题通常与懒加载有关，但并非总是如此。 任何类型的关系都可能出现这种问题。不过，它通常出现在多对多或一对多关系中。 3.1、延迟加载 首先，来看看懒加载是如何导致 N+1 问题的，示例如下： @Entity public class User { @Id private Long id; private String username; private String email; @OneToMany(cascade = CascadeType.ALL, mappedBy = "author") protected List<Post> posts; // 构造函数/getter/setter } User 与 Post 之间是一对多的关系。这意味着每个 User 都有多个 Post。我们没有明确确定字段的 Fetch 策略。策略是从注解中推断出来的。如前所述，@OneToMany 默认采用 Lazy Fetch 策略： https://springdoc.cn/spring-aspect-oriented-programming-logging/ Fri, 23 Feb 2024 10:37:51 +0800 https://springdoc.cn/spring-aspect-oriented-programming-logging/ 1、概览 Aspect-Oriented Programming（面向切面编程，简称 AOP）是一种范式，它能让我们在整个应用中隔离事务管理或日志记录等交叉问题，而不会干扰业务逻辑。 本文将带你了解如何在 Spring 中使用 AOP 记录执行日志。 2、不使用 AOP 记录日志 通常，我们会在方法的开始和结束处输出日志。这样，就能跟踪应用的执行流程。此外，还可以捕获传递给特定方法的值及其返回值。 示例如下： public String greet(String name) { logger.debug(">> greet() - {}", name); String result = String.format("Hello %s", name); logger.debug("<< greet() - {}", result); return result; } 尽管上面的实现看起来是一个标准的解决方案，但日志语句在代码中增加了复杂性。 如果没有日志记录，只需要一行代码就可以完成： public String greet(String name) { return String.format("Hello %s", name); } 3、面向切面（AOP）编程 顾名思义，面向切面的编程（Aspect-Oriented Programming）侧重于切面，而不是对象和类。我们可以使用 AOP 编程为特定应用实现额外功能，而无需修改其当前实现。 3.1、AOP 概念 在深入学习之前，让我们先从高层次来了解一下 AOP 的基本概念。 切面（Aspect）：横切关注点或我们希望在整个应用中应用的功能。 连接点（Join Point）：应用流程中我们希望应用切面的点。 Advice：在特定连接点应执行的操作。 Pointcut：应在其中应用某一切面的连接点集合。 另外，Spring AOP 仅支持方法执行的连接点。可以考虑使用 AspectJ 等编译时库为字段、构造函数、静态初始化器等创建切面。 https://springdoc.cn/spring-boot-3-2-3-available-now/ Fri, 23 Feb 2024 10:01:20 +0800 https://springdoc.cn/spring-boot-3-2-3-available-now/ ⚠️ 注意 此版本升级到 Hibernate 6.4.4.Final。虽然它包含了许多有价值的错误修复，但在原生镜像（Native Image）中无法正常工作。如果你正在使用 GraalVM，则应在 pom.xml 中使用 hibernate.version 属性将 Hibernate 暂时降级到 6.4.2.Final。 🐞 Bug 修复 如果路径中包含空格，无法解析嵌套的 JAR URL #39675 当使用较长的镜像名称且标记包含非法字符时，镜像构建会运行很长时间 #39638 Banner 打印不遵守设置的字符集 #39621 “micrometer.observations.” 配置属性应为 “management.observations.” #39600 配置类解析过程中的元数据读取使用默认资源加载器，而不是应用的资源加载器 #39598 当将一些 Gson 属性（包括 spring.gson.disable-html-escaping）设置为 false 时，它们的行为不正确 #39524 当配置属性绑定使用转换器从属性值创建一个 Map 时，属性占位符不会被解析 #39515 Gradle 插件允许使用 Gradle 7.4，但文档和测试的最低版本是 7.5 #39513 WebFlux 自动配置应仅在启用虚拟线程时配置 blocking executor #39469 TestcontainersPropertySource 断言有错别字 #39449 缺少参数时，Webflux actuator 端点的响应为 500 #39444 使用 non-shaded Pulsar 客户端和配置身份验证参数时出现 NoSuchMethod 错误 #39389 Jetty GracefulShutdown 会写入 System. https://springdoc.cn/spring-jpa-onetomany-list-vs-set/ Sun, 04 Feb 2024 11:14:18 +0800 https://springdoc.cn/spring-jpa-onetomany-list-vs-set/ 1、概览 Spring JPA 和 Hibernate 为不同据库通信提供了强大的工具。然而，随着开发者将更多的控制权（包括查询生成）委托给框架，结果可能与我们的预期相去甚远。 开发者通常会对在多对多关系中使用列表（List）还是集合（Set）产生困惑。而且，Hibernate 对其 bag、list 和 set 使用了类似的名称，但它们之间有稍微不同的含义，这进一步增加了混淆的可能性。 在大多数情况下，Set 更适用于一对多或多对多关系。不过，它们对性能有特殊的影响，需要注意。 本文将带你了解 JPA 实体关系中 List 和 Set 的区别，以及各自的优缺点。 2、测试 这里使用专门的测试库来测试请求数。检查日志不是一个好的解决方案，因为它不是自动化的，可能只适用于简单的示例。当请求产生数十或数百个查询时，使用日志是不够高效的。 首先，需要 io.hypersistence。注意，artifact ID 中的数字是 Hibernate 版本： <dependency> <groupId>io.hypersistence</groupId> <artifactId>hypersistence-utils-hibernate-63</artifactId> <version>3.7.0</version> </dependency> 此外，还使用 util 库进行日志分析： <dependency> <groupId>com.vladmihalcea</groupId> <artifactId>db-util</artifactId> <version>1.0.7</version> </dependency> 我们应该使用所提供的 Util 来 封装数据源，使其正常工作。这可以通过 BeanPostProcessor 来做实现： @Component public class DataSourceWrapper implements BeanPostProcessor { public Object postProcessBeforeInitialization(Object bean, String beanName) { return bean; } public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof DataSource originalDataSource) { ChainListener listener = new ChainListener(); SLF4JQueryLoggingListener loggingListener = new SLF4JQueryLoggingListener(); loggingListener. https://springdoc.cn/spring-boot-jpa-storing-postgresql-jsonb/ Sat, 03 Feb 2024 11:08:20 +0800 https://springdoc.cn/spring-boot-jpa-storing-postgresql-jsonb/ 1、概览 本文将带你全面了解如何使用 Spring Data JPA 在 PostgreSQL JSONB 列中存储、检索 JSON 数据。 2、VARCHAR 映射 本节将介绍如何使用 AttributeConverter 将 VARCHAR 类型的 JSON 值转换为自定义 Java POJO。 其目的是方便 Java 数据类型中的实体属性值与数据库列中的相应值之间的转换。 2.1、Maven 依赖 要创建 AttributeConverter，必须在 pom.xml 中加入 Spring Data JPA 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <version>2.7.18</version> </dependency> 2.2、数据表定义 数据库表定义如下： CREATE TABLE student ( student_id VARCHAR(8) PRIMARY KEY, admit_year VARCHAR(4), address VARCHAR(500) ); student 表有三个字段，其中我们希望 address 列能存储具有以下结构的 JSON 值： { "postCode": "TW9 2SF", "city": "London" } 2.3、Entity 类 创建一个相应的 POJO 类，用 Java 表示 address 数据： https://springdoc.cn/spring-webclient-json-custom-deserialization/ Sat, 03 Feb 2024 10:28:51 +0800 https://springdoc.cn/spring-webclient-json-custom-deserialization/ 1、概览 本文将带你了解如何在 Spring WebClient 中自定义 JSON 的反序列化（Deserialization）。 2、为什么需要自定义反序列化？ Spring WebFlux 模块中的 Spring WebClient 通过 Encoder 和 Decoder 组件处理序列化和反序列化。编码器（Encoder）和解码器（Decoder）是表示读取和写入内容的接口。默认情况下，spring-core 模块提供 byte[]、ByteBuffer、DataBuffer、Resource 和 String 编码器和解码器实现。 Jackson 是一个 JSON 库，它通过 ObjectMapper 将 Java 对象序列化为 JSON，并将 JSON 字符串反序列化为 Java 对象。ObjectMapper 包含内置的配置选项，可以使用 Deserialization Feature 进行开启或关闭。 当 Jackson 库提供的默认行为无法满足我们的特定需求时，就有必要定制反序列化过程。为了在序列化和反序列化过程中修改行为，ObjectMapper 提供了一系列配置选项供我们设置。因此，我们需要将这个自定义的 ObjectMapper 注册到 Spring WebClient 中，以便在序列化和反序列化中使用。 3、如何自定义 ObjectMapper？ 自定义 ObjectMapper 可以在全局应用程序级别与 WebClient 关联，也可以与特定请求关联。 以一个获取客户订单详细信息的 GET 端点为例。 OrderResponse Model 如下： { "orderId": "a1b2c3d4-e5f6-4a5b-8c9d-0123456789ab", "address": [ "123 Main St", "Apt 456", "Cityville" ], "orderNotes": [ "Special request: Handle with care", "Gift wrapping required" ], "orderDateTime": "2024-01-20T12:34:56" } 对于上述响应的一些反序列化规则如下： https://springdoc.cn/spring-boot-grpc-intro/ Sun, 28 Jan 2024 18:31:03 +0800 https://springdoc.cn/spring-boot-grpc-intro/ 1、简介 gRPC 是一个高性能的开源 RPC 框架，最初由谷歌开发。它有助于消除样板代码，并在数据中心内外连接多语言服务。该 API 基于 Protocol Buffer，它提供了一个 protoc 编译器，用于生成不同支持的语言的代码。 我们可以将 gRPC 视为 REST、SOAP 或 GraphQL 的替代品，它建立在 HTTP/2 的基础上，可以使用多路复用或流式连接等功能。 本文将带你了解如何使用 Spring Boot 实现 gRPC 服务提供者和消费者。 2、面临的问题 首先，Spring Boot 并不直接支持 gRPC。它只支持 Protocol Buffer，允许我们实现基于 protobuf 的 REST 服务。因此，需要通过使用第三方库来加入 gRPC： 平台相关的编译器：protoc 编译器是平台相关的。因此，如果在构建过程中需要生成存根（Stub），构建过程会变得更加复杂且容易出错。 依赖： 需要在 Spring Boot 应用中添加兼容的依赖。不幸的是，Java 的 protoc 添加了 javax.annotation.Generated 注解（Issues），这迫使我们需要添加一个依赖项来编译旧的 Java EE 注解库。 服务器运行时：gRPC 服务提供者需要在服务器中运行。gRPC for Java 项目提供了一个 shaded Netty，我们需要将其包含在 Spring Boot 应用中，或者用 Spring Boot 已经提供的服务器来代替。 消息传输： Spring Boot 提供了不同的客户端，如 RestClient（阻塞）或 WebClient（非阻塞），但遗憾的是，这些客户端无法配置和用于 gRPC，因为 gRPC 在阻塞和非阻塞调用中都使用了 自定义 transport 技术。 配置： 由于 gRPC 使用了自己的技术，我们需要配置属性以按照 Spring Boot 的方式对其进行配置。 3、示例项目 幸运的是，可以使用第三方 Spring Boot Starter 来应对这些挑战，例如 LogNet 或 grpc ecosystem project。这两个 Starter 都很容易整合，但后者同时支持提供者和消费者以及许多其他集成功能，因此本文选择了后者。 https://springdoc.cn/spring-modulith-event-externalization/ Sun, 28 Jan 2024 17:45:42 +0800 https://springdoc.cn/spring-modulith-event-externalization/ 1、概览 本文将带你了解如何使用 Spring Modulith 来监听 Spring Application Event 并自动将其发布到 Kafka Topic。 2、事务操作和 Message Broker 假设，正在开发一个保存文章的功能： @Service class Baeldung { private final ArticleRepository articleRepository; // 构造函数 @Transactional public void createArticle(Article article) { validateArticle(article); article = addArticleTags(article); // ...其他业务逻辑 articleRepository.save(article); } } 此外，还需要向系统的其他部分通知这一新文章。其他模块或服务会根据此做出反应，例如创建报告或向网站读者发送新闻邮件。 最简单的方法是使用 KafkaOperations 向 baeldung.articles.published Kafka Topic 发送消息，并使用文章的 slug() 作为关 Key： @Service class Baeldung { private final ArticleRepository articleRepository; private final KafkaOperations<String, ArticlePublishedEvent> messageProducer; // 构造函数 @Transactional public void createArticle(Article article) { // . https://springdoc.cn/java-httpservletrequest-get-query-parameters/ Sun, 21 Jan 2024 12:14:31 +0800 https://springdoc.cn/java-httpservletrequest-get-query-parameters/ 1、概览 后端 HTTP API 开发最重要的功能之一是解析前端传递的请求查询参数。 本文将带你了解几种直接从 HttpServletRequest 获取查询参数的方法，以及 Spring MVC 提供的一些简洁方法。 2、HttpServletRequest 中的方法 首先，来看看 HttpServletRequest 提供的与参数相关的方法。 2.1、HttpServletRequest#getQueryString() HttpServletRequest#getQueryString() 可以直接从 URL 获取查询字符串信息： @GetMapping("/api/byGetQueryString") public String byGetQueryString(HttpServletRequest request) { return request.getQueryString(); } 使用 curl 向该 API 发送一个包含多个参数的 GET 请求时，getQueryString() 方法会返回 ? 后面的所有字符： $ curl 'http://127.0.0.1:8080/spring-mvc-basics/api/byGetQueryString?username=bob&roles=admin&roles=stuff' username=bob&roles=admin&roles=stuff 如果将 @GetMapping 更改为 @RequestMapping，当使用 POST/PUT/PATCH/DELETE HTTP 方法发送请求时，返回的响应相同。也就是说 HttpServletRequest#getQueryString 始终获取到的是 URL 中的查询参数，无论 HTTP 方法是什么。因此，本教程只关注GET请求。 2.2、HttpServletRequest#getParameter(String) 为了简化参数的解析，HttpServletRequest 提供了一个 getParameter 方法，可以通过参数名获取参数值： @GetMapping("/api/byGetParameter") public String byGetParameter(HttpServletRequest request) { String username = request. https://springdoc.cn/spring-boot-redis-reliable-mq/ Sat, 20 Jan 2024 11:44:56 +0800 https://springdoc.cn/spring-boot-redis-reliable-mq/ 在应用中把 Redis 当成消息队列来使用已经屡见不鲜了。我想主要原因是当代应用十有八九都会用到 Redis，因此不用再引入其他消息队列系统。而且 Redis 提供了好几种实现消息队列的方法，用起来也简单。 使用 Redis 实现消息队列的几种方式 Redis 提供了多种方式来实现消息队列。 Pub/Sub 订阅发布模式，发布者把消息发布到某个 Channel，该 Channel 的所有订阅者都会收到消息。但是这种方式最大的问题是 发布出去的消息，如果没有被监听消费，或者消费过程中宕机，那么消息就会永远丢失。适合用于临时通知之类的场景，对于需要保证数据不丢失的场景不能使用这种方式。 List List 是 Redis 提供的一种数据类型，底层是链表，可以用来实现队列、栈。 Stream Stream 是一个由 Redis 5 引入的，功能完善的消息队列。想必也是 Redis 官方团队看到太多人拿 Redis 当消息队列使，于是干脆就在 Redis 上设计出一个类似于 Kafka 的消息队列。 Steam 支持消费组消费，一条消息只能被消费组中的其中一个消费者消费。支持 消息确认、支持 回溯消费 还支持把未 ACK（确认）的消息转移给其他消费者进行重新消费，在进行转移的时候还会累计消息的转移次数，当次数达到一定阈值还没消费成功，就可以放入死信队列。 这也是 Redis 种最复杂的一种数据类型。如果你真的到了需要使用 Redis Steam 作为消息队列的地步，那不如直接使用 RabbitMQ 等更加成熟且稳定的消息队列系统。 使用 List 实现可靠的消息队列 目前来说，这是用得最多的一种方式，适用于大多数简单的消息队列应用场景。List 类型有很多指令，但是作为消息队列来说用到的只有几个个： LPUSH key element [element ...] 把元素插入到 List 的首部，如果 List 不存在，会自动创建。 BRPOPLPUSH source destination timeout 移除并且返回 List （source）尾部的最后一个元素，并且同时会把这个元素插入到另一个 List （destination）的首部。 https://springdoc.cn/spring-boot-3-2-2-available-now/ Sat, 20 Jan 2024 11:20:49 +0800 https://springdoc.cn/spring-boot-3-2-2-available-now/ Spring Boot 3.2.2 版本的详细更新内容如下： 🐞 Bug 修复 SSLBundle 实现未提供有用的 toString() 结果 #39167 JarEntry.getComment() 从 NestedJarFile 实例返回不正确的结果 #39166 在 server.ssl 属性中混合 PEM 和 JKS 类型的证书不起作用 #39158 仅仅在 classpath 上引入 AspectJ 和 Micrometer 并不足以启用对 Micrometer observation 注解的支持 #39128 当映射到 / 时，无法访问未使用选择器（Selector）操作的 Actuator 端点。#39122 由于缺少 Authentication Manager，使用 WebFlux、Security 和 Actuator 的 Spring Boot 3.2 应用可能无法启动 #39096 management.observations.http.server.requests.name 不再生效 #39083 spring.rabbitmq.listener.stream.auto-startup 属性不起作用 #39078 PatternParseException 的日志信息中的错误标记位置不对 #39075 server.jetty.max-connections 配置无效 #39052 依赖于初始的 CharSequence 到 String 转换的 @ConfigurationPropertiesBinding 转换器不再起作用 #39051 在新的加载器实现中无法解析 Manifest attributes #38996 来自日志系统初始化的 Throwable 可能导致应用在启动时默默地失败 #38963 使用 Jetty 时，IO 操作和延迟调度的空闲超时不能设置为小于 30000ms #38960 当 jar 放在 WSL 网络驱动器上时，spring-boot-maven-plugin repackage uber jar 执行失败 #38956 Oracle OJDBC BOM 版本被标记为不适合生产使用 #38943 使用 jOOQ 且未设置 spring. https://springdoc.cn/spring-cloud-global-exception-handling/ Sat, 20 Jan 2024 10:46:41 +0800 https://springdoc.cn/spring-cloud-global-exception-handling/ 1、概览 本文将带你了解如何在 Spring Cloud Gateway 中实现全局异常处理。 在现代软件开发中，尤其是在微服务中，API 的高效管理至关重要。这正是 Spring Cloud Gateway 作为 Spring 生态系统的关键组件发挥重要作用的地方。它就像一个门卫，将流量和请求引导到适当的微服务，并提供跨切面的关注点，如安全性、监控/指标和弹性。 然而，在如此复杂的环境中，由于网络故障、服务宕机或应用错误而产生的异常是必然的，这就需要一个强大的异常处理机制。Spring Cloud Gateway 的全局异常处理可确保在所有服务中采用一致的错误处理方法，并增强整个系统的弹性和可靠性。 2、全局异常处理的必要性 Spring Cloud Gateway 是 Spring 生态系统中的一个项目，旨在作为微服务架构中的 API 网关，其主要作用是根据预先制定的规则将请求路由到相应的微服务。网关提供安全（认证和授权）、监控和熔断（Circuit Breakers）等功能。通过处理请求并将其导向适当的后端服务，它有效地管理了诸如安全性和流量管理等横切关注点。 在微服务等分布式系统中，异常可能来自多个方面，如网络问题、服务不可用、下游服务错误和应用级错误，这些都是常见的罪魁祸首。在这种环境下，以本地化方式（即在每个服务内）处理异常可能会导致零散和不一致的错误处理。这种不一致性会使调试工作变得繁琐，并降低用户体验： 全局异常处理通过提供集中的异常管理机制，确保所有异常（无论其来源如何）都能得到一致的处理，并提供标准化的错误响应，从而应对这一挑战。 这种一致性对于系统恢复能力、简化错误跟踪和分析至关重要。它还能提供精确一致的错误格式，帮助用户了解出错的原因，从而提升用户体验。 3、在 Spring Cloud Gateway 中实现全局异常处理 在 Spring Cloud Gateway 中实现全局异常处理涉及几个关键步骤，每个步骤都能确保建立一个强大而高效的异常管理系统。 3.1、创建自定义全局异常处理器 全局异常处理器对于捕获和处理网关中发生的异常至关重要。为此，需要继承 AbstractErrorWebExceptionHandler 并将其添加到 Spring Context 中。这样，就创建了一个能拦截所有异常的集中式处理器。 @Component public class CustomGlobalExceptionHandler extends AbstractErrorWebExceptionHandler { // 构造函数和其他方法 } 该类应能处理各种类型的异常，从 NullPointerException 等一般异常到 HttpClientErrorException 等更具体的异常。目标是涵盖各种可能的错误。该类的核心方法如下所示。 @Override protected RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes) { return RouterFunctions. https://springdoc.cn/spring-webflux-upload-multiple-files/ Sat, 20 Jan 2024 09:58:41 +0800 https://springdoc.cn/spring-webflux-upload-multiple-files/ 1、概览 Spring WebFlux 是一个响应式 Web 框架，它提供了一个非阻塞 Event Loop，可异步处理 I/O 操作。此外，它还使用 Mono 和 Flux Reactive Stream Publisher 在订阅时发布数据。 这种响应式方式可帮助应用处理大量请求和数据，而无需分配大量资源。 本文将带你了解如何在 Spring WebFlux 中处理 Multipart 文件上传。 2、项目设置 创建一个简单的响应式 Spring Boot 项目，将 Multipart 文件上传到一个目录。 为简单起见，使用项目的根目录来存储文件。在生产中，可以使用 云厂商 OSS、Minio 存储等文件系统。 2.1、Maven 依赖 首先，在 pom.xml 中添加 spring-boot-starter-webflux 依赖，以启动 Spring WebFlux 应用： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> <version>3.2.0</version> </dependency> 它提供核心 Spring WebFlux API 和嵌入式 Netty 服务器，用于构建响应式 Web 应用。 另外，还要在 pom.xml 文件中添加 spring-boot-starter-data-r2dbc 和 H2 数据库依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-r2dbc</artifactId> <version>3.2.0</version> </dependency> <dependency> <groupId>com. https://springdoc.cn/spring-jwt-access-tokens-authorities-custom-claims/ Sun, 14 Jan 2024 17:35:31 +0800 https://springdoc.cn/spring-jwt-access-tokens-authorities-custom-claims/ 1、概览 在许多情况下，可以在 JWT Access Token 添加自定义 Claim，从而在 Token Payload 中包含更多信息。 本文将带你了解如何在 Spring Authorization Server 中为 JWT Access Token 添加资源所有者授权。 2、Spring Authorization Server Spring Authorization Server 是 Spring 生态系统中的一个新项目，旨在为 Spring 应用提供授权服务器支持。它通过 Spring 编程模型简化 OAuth 2.0 和 OpenID Connect（OIDC） 授权服务器的实现。 2.1、Maven 依赖 首先，在 pom.xml 中导入 spring-boot-starter-web、spring-boot-starter-security、spring-boot-starter-test 和 spring-security-oauth2-authorization-server 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.5.4</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> <version>2.5.4</version> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-oauth2-authorization-server</artifactId> <version>0.2.0</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <version>2.5.4</version> </dependency> 或者，可以在 pom.xml 文件中添加 spring-boot-starter-oauth2-authorization-server 依赖： https://springdoc.cn/junit-5-parameterresolutionexception/ Sun, 14 Jan 2024 17:04:56 +0800 https://springdoc.cn/junit-5-parameterresolutionexception/ 1、概览 JUnit 5 引入了一些强大的功能，包括支持参数化测试（parameterized testing）。编写参数化测试可以节省大量时间，而且在许多情况下，只需简单组合注解就能启用参数化测试。 然而，错误配置可能会导致难以调试的异常，例如：ParameterResolutionException。 org.junit.jupiter.api.extension.ParameterResolutionException: No ParameterResolver registered for parameter ... 本文将带你了解如何解决 ParameterResolutionException 异常。 2、JUnit 5 的 ParameterResolver 异常信息中表示缺少 ParameterResolver。 这是 JUnit 5 中引入的 ParameterResolver 接口，允许开发人员扩展 JUnit 的基本功能，编写可接受任何类型参数的测试。 来看一个简单的 ParameterResolver 实现： public class FooParameterResolver implements ParameterResolver { @Override public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException { // 是否支持参数类型的逻辑 } @Override public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException { // 参数解析逻辑 } } 该类有两个主要方法： supportsParameter()：确定是否支持参数类型 resolveParameter()：返回执行测试的参数 因为 ParameterResolutionsException 是在没有 ParameterResolver 实现的情况下抛出的，所以先不关心实现细节。首先来看看异常的一些潜在原因。 https://springdoc.cn/spring-ai-intro/ Mon, 08 Jan 2024 19:56:48 +0800 https://springdoc.cn/spring-ai-intro/ 1、概览 Spring 通过 Spring AI 项目正式启用了 AI（人工智能）生成提示功能。本文将带你了解如何在 Spring Boot 应用中集成生成式 AI，以及 Spring AI 如何与模型互动。 2、Spring AI 的主要概念 首先回顾一下一些关键的领域术语和概念。 Spring AI 最初专注于处理语言输入和生成语言输出的模型。该项目的理念是为开发人员提供一个抽象接口，为将生成式 AI 作为独立组件纳入应用奠定基础。 接口 AiClient 就是这样一个抽象，它有两个基本实现：OpenAI 和 Azure OpenAI。 public interface AiClient { default String generate(String message); AiResponse generate(Prompt prompt); } AiClient 为生成函数提供了两个选项。简化版生成函数：generate(String message)，使用 String 作为输入和输出，可以避免使用 Prompt 和 AiResponse 类的额外复杂性。 2.1、高级的 Prompt 和 AiResponse 在 AI 领域，Prompt（提示）是指提供给 AI 的文本信息。它由上下文和问题组成，该模型用于生成答案。 从 Spring AI 项目的角度来看，Prompt 是一个参数化 Message 列表。 public class Prompt { private final List<Message> messages; // 构造函数和其他方法 } public interface Message { String getContent(); Map<String, Object> getProperties(); MessageType getMessageType(); } Prompt 使开发人员能够对文本输入进行更多控制。Prompt 模板就是一个很好的例子，它使用预定义文本和占位符集构建。然后，可以使用传递给 Message 构造函数的 Map<String, Object> 值填充它们。 https://springdoc.cn/spring-yaml-inject-map/ Sun, 07 Jan 2024 11:56:03 +0800 https://springdoc.cn/spring-yaml-inject-map/ 1、概览 本文将带你了解如何在 Spring Boot 中把 YAML 属性注入到 Map。 2、Spring 中的 YAML 文件 使用 YAML 文件存储外部配置数据是 Spring 开发人员的常见做法。Spring 支持使用 YAML 作为 Properties 的替代。 Spring 底层使用 SnakeYAML 来解析 YAML。 话不多说，来看看典型的 YAML 文件是什么样的： server: port: 8090 application: name: myapplication url: http://myapplication.com 如你所见，YAML 文件不言自明，而且更易于人阅读。YAML 提供了一种精美而简洁的方式来存储层次化的配置数据。 默认情况下，Spring Boot 会在应用启动时从 application.properties 或 application.yml 中读取配置属性。不过，可以使用 @PropertySource 来加载自定义 YAML 文件。 熟悉了 YAML 文件后，来看看如何在 Spring Boot 中将 YAML 属性注入到 Map 中。 3、将 YAML 属性注入到 Map 通过 @ConfigurationProperties 注解，Spring Boot 可轻松地将配置文件中的外部属性直接注入 Java 对象。 https://springdoc.cn/kafka-spring-dead-letter-queue/ Sun, 07 Jan 2024 11:08:28 +0800 https://springdoc.cn/kafka-spring-dead-letter-queue/ 1、简介 本文将带你了解如何在 Spring 中为 Apache Kafka 配置死信队列。 2、死信队列 死信队列（Dead Letter Queue，DLQ）用于存储由于各种原因无法正确处理的消息，例如间歇性系统故障、无效的消息模式或损坏的内容。这些消息可以稍后从 DLQ 中移除，以进行分析或重新处理。 下图是 DLQ 机制的简化流程： 通常情况下，使用 DLQ 是一个不错的主意，但也有一些情况下应该避免使用 DLQ。例如，在对消息的精确顺序很重要的队列中，不建议使用 DLQ，因为重新处理 DLQ 消息会打乱消息的到达顺序。 3、Spring Kafka 中的死信队列 在 Spring Kafka 中，与 DLQ 概念相对应的是死信 Topic（DLT）。 接下来，我们通过一个简单的支付系统来介绍 DLT 应该如何使用。 3.1、Model 类 从 Model 类开始： public class Payment { private String reference; private BigDecimal amount; private Currency currency; // Get、Set 方法省略 } 再实现一个用于创建事件的方法： static Payment createPayment(String reference) { Payment payment = new Payment(); payment.setAmount(BigDecimal.valueOf(71)); payment. https://springdoc.cn/spring-boot-enum-bind-case-insensitive-value/ Sun, 07 Jan 2024 10:20:23 +0800 https://springdoc.cn/spring-boot-enum-bind-case-insensitive-value/ 1、概览 Spring 提供了自动配置功能，可以用它来绑定组件、配置 Bean 以及从属性源中设置值。 当我们不想硬编码值，而希望使用 properties 文件或系统环境提供值时，@Value 注解就非常有用。 本文将带你了解如何通过 Spring 自动配置将属性值映射到 Enum 实例，不区分大小写。 2、Converter<F,T> Spring 使用 Converter 将 @Value 注解中的 String 值映射到所需的类型。一个专用的 BeanPostProcessor 会遍历所有组件，并检查它们是否需要额外的配置或注入。然后，找到一个合适的 Converter，并将源 Converter 中的数据绑定目标。Spring 提供了一个内置的 String 到 Enum 类型的 Converter，让我们来详细了解一下。 2.1、LenientToEnumConverter 顾名思义，该 Converter 在转换过程中可以自由解释数据。最初，它假定提供的数值是正确的： @Override public E convert(T source) { String value = source.toString().trim(); if (value.isEmpty()) { return null; } try { return (E) Enum.valueOf(this.enumType, value); } catch (Exception ex) { return findEnum(value); } } 不过，如果无法将源映射到 Enum，它就会尝试另一种方法。它会获取 Enum 和 value 的规范名称： https://springdoc.cn/use-hexformat-to-format-the-16-barred/ Sat, 06 Jan 2024 11:52:12 +0800 https://springdoc.cn/use-hexformat-to-format-the-16-barred/ 十六进制（Hexadecimal）是一种数制系统，它使用 16 个数字来表示数值，分别是 0 到 9 和 A 到 F。 十六进制经常用于表示字节数据。在十六进制表示中，一个字节可以用两个十六进制数字表示。例如，字节的取值范围是 0 到 255，可以用 00 到 FF 来表示。其中，00 表示二进制的 00000000，FF 表示二进制的 11111111。这在 Socket 通信协议的定义中很常见。 简单来说，对于一些较短的二进制数据，可以把它序列化为十六进制字符串，其中每 2 个字符，表示一个字节。同样，也可以把十六进制的字符串解析为字节数组。最常见的场景就是把 Hash 计算的结果表示为十六进制字符串。 通常我们可以选择使用第三方的 commons-codec 库来实现格式化和解析十六进制字符串。可能是这个功能需求太常见，于是从JDK 17 开始，标准库中提供了一个 HexFormat 工具类，用于格式化和解析十六进制字符串。 简单地编码和解码 简单地把字节数组编码为十六进制字符串，以及把十六进制字符串解析为字节数组。 package cn.springdoc.demo.test; import java.util.HexFormat; public class Main { public static void main(String[] args) throws Exception { HexFormat format = HexFormat.of(); String hex = format.formatHex("hello springdoc.cn".getBytes()); System.out.println("Hex=" + hex); byte[] bytes = format.parseHex(hex); System. https://springdoc.cn/spring-data-jpa-getreferencebyid-findbyid-methods/ Sat, 06 Jan 2024 10:50:11 +0800 https://springdoc.cn/spring-data-jpa-getreferencebyid-findbyid-methods/ 1、概览 JpaRepository 供了 CRUD 操作的基本方法。其中 getReferenceById(ID) 和 findById(ID) 是经常引起混淆的方法。这些方法是 getOne(ID)、findOne(ID) 和 getById(ID) 的新 API 名称。 本文将带你了解这些方法之间的区别，以及各自的适用场景。 2、findById() 这个方法按照其名称所示，根据给定的 ID 在 Repository 中查找实体： @Override Optional<T> findById(ID id); 该方法返回一个 Optional。因此，如果传递了一个不存在的 ID，返回的 Optional 对象将为 empty。 该方法使用了急切加载功能，因此只要调用该方法，就会向数据库发送请求。 执行如下示例： public User findUser(long id) { log.info("Before requesting a user in a findUser method"); Optional<User> optionalUser = repository.findById(id); log.info("After requesting a user in a findUser method"); User user = optionalUser.orElse(null); log.info("After unwrapping an optional in a findUser method"); return user; } 输出的日志如下： https://springdoc.cn/hibernate-queryexception-named-parameter-not-bound-fix/ Sat, 06 Jan 2024 10:37:28 +0800 https://springdoc.cn/hibernate-queryexception-named-parameter-not-bound-fix/ 1、概览 本文将带你了解如何解决 Hibernate 异常 QueryException: “named parameter not bound”。 2、理解异常 简而言之，在将 Hibernate 查询转换为 SQL 时，由于语法无效，Hibernate 会抛出 QueryException 来提示错误。“named parameter not bound” 表明 Hibernate 无法绑定特定查询中指定的命名参数。 通常情况下，命名参数的前缀是冒号（:），后面是一个占位符，表示在执行查询之前需要设置的实际值： SELECT p FROM Person p WHERE p.firstName = :firstName; 造成异常的最常见原因之一是忘记为 Hibernate 查询中的命名参数赋值。 3、重现异常 理解了导致异常的原因后，通过一个实际的例子来重现这个异常。 创建如下 Person 实体类： @Entity public class Person { @Id private int id; private String firstName; private String lastName; // 标准的 Get、Set } 如上，@Entity 注解表示类是一个实体，它映射了数据库中的一个表。此外，@Id 表示 id 属性代表主键。 现在，创建一个带有命名参数的 Hibernate 查询，并假装忘记为参数设置值： @Test void whenNotSettingValueToNamedParameter_thenThrowQueryException() { Exception exception = assertThrows(QueryException. https://springdoc.cn/kafka-send-data-partition/ Sat, 06 Jan 2024 09:39:54 +0800 https://springdoc.cn/kafka-send-data-partition/ 1、简介 Apache Kafka 是一个分布式流平台，擅长处理海量实时数据流。Kafka 将数据组织成 Topic（主题），并进一步将 Topic 划分为 Partition（分区）。每个分区都是一个独立的 Channel（通道），可实现并行处理和容错。 本文将带你了解如何把数据发送到 Kafka 中特定的分区。 2、理解 Kafka 分区 首先来了解一下 Kafka 分区的基本概念。 2.1、什么是 Kafka 分区？ 当生产者向 Kafka Topic 发送消息时，Kafka 会使用指定的分区策略将这些消息组织到分区中。分区是一个基本单元，代表了线性、有序的消息序列。消息一旦产生，就会根据所选的分区策略被分配到一个特定的分区。随后，消息会被附加到该分区中日志的末尾。 2.2、并行消费与消费组 一个 Kafka Topic 可分为多个分区，一个消费组（Consumer Group）可被分配到这些分区的一个子集。组内的每个消费者都会独立处理来自其分配分区的消息。这种并行处理机制提高了整体吞吐量和可扩展性，使 Kafka 能够高效地处理大量数据。 2.3、顺序保证 在单个分区中，Kafka 可确保按照接收到的相同顺序处理消息。这保证了依赖消息顺序的应用（如金融交易或事件日志）的顺序处理。不过，需要注意的是，由于网络延迟和其他操作因素，接收消息的顺序可能与最初发送消息的顺序不同。 在不同的分区中，Kafka 并不保证顺序。来自不同分区的消息可能会被并发处理，从而带来事件顺序变化的可能性。在设计依赖于严格消息顺序的应用时，需要考虑到这个特性。 2.4、容错和高可用 分区还有助于 Kafka 实现出色的容错能力。每个分区都可以在多个 Broker 之间复制。如果 Broker 发生故障，副本分区仍可被访问，并确保对数据的持续访问。 Kafka 集群可以将消费者无缝重定向到健康的 Broker，从而保持数据的可用性和系统的高可靠性。 3、为什么要将数据发送到特定分区？ 3.1、数据亲和性 数据亲和性是指有意将相关数据归入同一分区。通过将相关数据发送到特定分区，可以确保这些数据一起处理，从而提高处理效率。 例如，考虑一个场景，我们可能希望确保客户的订单位于同一个分区中，以便进行订单追踪和分析。保证特定客户的所有订单都进入同一个分区可以简化追踪和分析过程。 3.2、负载均衡 此外，在分区之间均匀地分配数据有助于确保最佳的资源利用率。在分区之间平均分配数据有助于优化 Kafka 集群内的资源利用率。通过根据负载情况向分区发送数据，可以防止出现资源瓶颈，确保每个分区都能接收到可管理的均衡工作量。 3.3、优先顺序 在某些情况下，并非所有数据都具有相同的优先级或紧迫性。Kafka 的分区功能可将关键数据引导到专用分区进行快速处理，从而实现关键数据的优先级排序。与不太重要的数据相比，这种优先级排序可确保高优先级的消息得到及时关注和更快处理。 4、向特定分区发送数据的方式 Kafka 提供了将消息分配到分区的各种策略，从而提供了数据分布和处理的灵活性。下面是一些可用于将消息发送到特定分区的常用方法。 4.1、粘性分区器（Sticky Partitioner） 在 Kafka 2.4 及以上版本中，粘性分区器（Sticky Partitioner）的目的是将没有 Key 的消息保持在同一个分区中。不过，这种行为并不是绝对的，它会与批处理设置（如 batch. https://springdoc.cn/spring-transaction-best-practices/ Mon, 01 Jan 2024 11:22:31 +0800 https://springdoc.cn/spring-transaction-best-practices/ 概览 本文将带你了解各种 Spring 事务的最佳实践，以保证底层业务的数据完整性。 数据完整性至关重要。如果没有适当的事务处理，应用就很容易出现竞赛条件，从而给底层业务带来可怕的后果。 模拟竞赛条件 以一个实际问题为例，说明在构建基于 Spring 的应用时，应该如何处理事务。 使用以下 Service 层和 Dao 层组件来实现转账服务： 使用最简单的 Dao 层实现来说明不按业务要求处理事务会发生什么情况： @Repository @Transactional(readOnly = true) public interface AccountRepository extends JpaRepository<Account, Long> { @Query(value = """ SELECT balance FROM account WHERE iban = :iban """, nativeQuery = true) long getBalance(@Param("iban") String iban); @Query(value = """ UPDATE account SET balance = balance + :cents WHERE iban = :iban """, nativeQuery = true) @Modifying @Transactional int addBalance(@Param("iban") String iban, @Param("cents") long cents); } getBalance 和 addBalance 方法都使用 Spring 的 @Query 注解来定义原生 SQL 查询，以检索或者修改用户的账户余额。 https://springdoc.cn/spring-xml-requestbody/ Mon, 01 Jan 2024 10:57:48 +0800 https://springdoc.cn/spring-xml-requestbody/ 1、概览 虽然 JSON 是 RESTful 服务的事实标准，但在某些情况下，可能需要使用 XML。例如：老掉牙的银行 API 就是通过 XML 进行交互的。 Spring 通过 Jackson XML 提供了一种简单的方法来支持 XML 端点。 2、依赖 第一步是添加 依赖。注意 spring-boot-starter-web Starter 默认不包含支持 XML 的库。需要手动添加： <dependency> <groupId>com.fasterxml.jackson.dataformat</groupId> <artifactId>jackson-dataformat-xml</artifactId> </dependency> 另外，也可以使用 JAXB 来实现，但总的来说，JAXB 更啰嗦，而且 API 没有 Jackson 那么优雅好用。不过，如果使用的是 Java 8，JAXB 库与实现都位于 javax 包中，因此无需在应用中添加任何其他依赖。 在 Java 9 开始的版本中，javax 包被移动并更名为 jakarta，因此 JAXB 需要额外的 依赖： <dependency> <groupId>jakarta.xml.bind</groupId> <artifactId>jakarta.xml.bind-api</artifactId> <version>4.0.0</version> </dependency> 另外，它需要一个运行时实现来处理 XML Mapper，这可能会导致其他的问题。 3、端点 由于 JSON 是 Spring REST Controller 的默认格式，因此需要在端点上明确配置 “消费” 和 “生产” 的数据类型是 XML： https://springdoc.cn/spring-data-return-map-instead-of-list/ Mon, 01 Jan 2024 10:27:22 +0800 https://springdoc.cn/spring-data-return-map-instead-of-list/ 1、概览 Spring JPA 为与数据库交互提供了非常灵活方便的 API。而且，还可以对其进行定制，以返回其他数据结构类型的返回值。 使用 Map 作为 JPA Repository 方法的返回类型有助于在服务和数据库之间创建更直接的交互。本文将带你了解如何在 Spring Data JPA Repository 接口的方法中返回 Map。 2、手动实现 当框架不提供某些功能时，最明显的解决方法就是自己实现。 2.1、List 可以把返回的 List 映射为 Map。通过 Stream API 只用一行代码就能实现： default Map<Long, User> findAllAsMapUsingCollection() { return findAll().stream() .collect(Collectors.toMap(User::getId, Function.identity())); } 2.2、Stream Repository 接口方法可以直接返回 Stream： @Query("select u from User u") Stream<User> findAllAsStream(); 之后，实现一个自定义方法，将结果映射到需要的数据结构中： @Transactional default Map<Long, User> findAllAsMapUsingStream() { return findAllAsStream() .collect(Collectors.toMap(User::getId, Function.identity())); } 返回 Stream 的 Repository 方法应在事务中调用。所以，直接在 default 方法中添加 @Transactional 注解。 2.3、Streamable 这与之前的方法类似。唯一的变化是返回 Streamable。先定义一个返回 Streamable 的方法： https://springdoc.cn/spring-security-basic-authentication/ Sun, 31 Dec 2023 12:32:30 +0800 https://springdoc.cn/spring-security-basic-authentication/ 1、概览 本文将带你了解如何通过 Spring Security 提供的 Basic Authentication 机制来保护 MVC 应用。 2、Spring Security 配置 使用 Java 配置来配置 Spring Security： @Configuration @EnableWebSecurity public class CustomWebSecurityConfigurerAdapter { @Autowired private RestAuthenticationEntryPoint authenticationEntryPoint; @Autowired public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { auth .inMemoryAuthentication() .withUser("user1") .password(passwordEncoder().encode("user1Pass")) .authorities("ROLE_USER"); } @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http.authorizeHttpRequests(expressionInterceptUrlRegistry -> expressionInterceptUrlRegistry.requestMatchers("/securityNone").permitAll() .anyRequest().authenticated()) .httpBasic(httpSecurityHttpBasicConfigurer -> httpSecurityHttpBasicConfigurer.authenticationEntryPoint(authenticationEntryPoint)); http.addFilterAfter(new CustomFilter(), BasicAuthenticationFilter.class); return http.build(); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } } 如上，在 SecurityFilterChain Bean 中使用 httpBasic() 来定义 Basic Authentication。 https://springdoc.cn/spring-security-authentication-provider/ Sun, 31 Dec 2023 12:04:52 +0800 https://springdoc.cn/spring-security-authentication-provider/ 1、概览 本文将带你了解如何在 Spring Security 中设置 Authentication Provider，相比于使用简单的 UserDetailsService 的标准方案，这样可以提供额外的灵活性。 2、Authentication Provider Spring Security 提供了多种执行身份认证的选项。这些选项遵循一个简单的契约；一个 AuthenticationProvider 处理一个身份认证请求，并返回一个带有完整凭证的认证对象。 最常见的标准实现是 DaoAuthenticationProvider，它从一个简单的 UserDetailsService（只读）中获取用户详细信息。这个 Service 只能通过用户名检索完整的用户实体，这在大多数情况下已足够。 更多的自定义场景仍需要访问完整的认证请求才能执行身份验证流程。例如，在对某些外部第三方服务进行身份验证时，身份认证请求中的 username 和 password 都是必要的。 对于这些更高级的场景，需要定义一个自定义的 Authentication Provider： @Component public class CustomAuthenticationProvider implements AuthenticationProvider { @Override public Authentication authenticate(Authentication authentication) throws AuthenticationException { String name = authentication.getName(); String password = authentication.getCredentials().toString(); if (shouldAuthenticateAgainstThirdPartySystem()) { // 使用凭证并对第三方系统进行身份认证 return new UsernamePasswordAuthenticationToken( name, password, new ArrayList<>()); } else { return null; } } @Override public boolean supports(Class<? https://springdoc.cn/spring-security-session/ Sun, 31 Dec 2023 10:21:38 +0800 https://springdoc.cn/spring-security-session/ 1、概览 本文将带你了解如何在 Spring Security 中配置 Session 超时、Session 并发以及其他高级的 Session 安全设置。 2、何时创建 Session？ 可以精确控制 Session 的创建时间，以及 Spring Security 与 Session 的交互方式： always：如果 Session 不存在，则会创建一个 Session。 ifRequired：仅在需要时才创建 Session（默认值）。 never：框架不会自己创建 Session，但如果 Session 已经存在，则会使用该 Session。 stateless：Spring Security 不会创建或使用 Session。 <http create-session="ifRequired">...</http> Java 配置如下： @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http.sessionManagement() .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED) return http.build(); } 注意，该配置只控制 Spring Security 的行为，而不是整个应用。如果指定 Spring Security 不创建 Session，它就不会创建 Session，但是应用可能会创建 Session！ 默认情况下，Spring Security 会在需要时创建一个 Session，即 ifRequired。 对于无状态应用，never 选项将确保 Spring Security 本身不会创建任何 Session。但如果应用创建了 Session，Spring Security 就会使用它。 https://springdoc.cn/log-request-response-via-content-caching-warpper/ Sat, 30 Dec 2023 12:00:13 +0800 https://springdoc.cn/log-request-response-via-content-caching-warpper/ 完整的请求日志对于 故障排查 和 审计 来说极其重要。通过查看日志，可以检查数据的准确性、参数的传递方式以及服务器返回的数据。 由于 Socket 流不能重读，所以需要一种实现来把读取和写入的数据缓存起来，并且可以多次重复读取缓存的内容。 Spring 提供 2 个可重复读取请求、响应的 Wrapper 工具类： ContentCachingRequestWrapper ContentCachingResponseWrapper 通过类名不难看出，这是典型的装饰者设计模式。它俩的作用就是把读取到的 请求体 和写出的 响应体 都缓存起来，并且提供了访问缓存数据的 API。 创建 RequestLogFilter 创建 RequestLogFilter 继承 HttpFilter，以记录完整的请求和响应日志。 package cn.springdoc.demo.web.filter; import java.io.IOException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.web.util.ContentCachingRequestWrapper; import org.springframework.web.util.ContentCachingResponseWrapper; import jakarta.servlet.FilterChain; import jakarta.servlet.ServletException; import jakarta.servlet.http.HttpFilter; import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletResponse; /** * 记录请求日志 */ public class RequestLogFilter extends HttpFilter { static final Logger log = LoggerFactory.getLogger(RequestLogFilter.class); /** * */ private static final long serialVersionUID = 8991118181953196532L; @Override protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException { // Wrapper 封装 Request 和 Response ContentCachingRequestWrapper cachingRequest = new ContentCachingRequestWrapper(request); ContentCachingResponseWrapper cachingResponse = new ContentCachingResponseWrapper(response); // 继续执行请求链 chain. https://springdoc.cn/get-user-in-spring-security/ Sat, 30 Dec 2023 10:58:06 +0800 https://springdoc.cn/get-user-in-spring-security/ 1、概览 本文介绍了如何在 Spring Security 中检索当前用户详细信息。 2、从 Bean 中获取用户 检索当前已通过身份认证用户（Principal）的最简单方式是调用 SecurityContextHolder 的静态方法： Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); String currentPrincipalName = authentication.getName(); 该代码需要改进的地方在于，在尝试访问之前，首先要检查是否存在已通过身份认证的用户： Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); if (!(authentication instanceof AnonymousAuthenticationToken)) { String currentUserName = authentication.getName(); return currentUserName; } 当然，这样的静态调用也有缺点，代码的可测试性降低了。 3、在 Controller 中获取用户 在 @Controller 中，可以直接将 Principal 定义为方法参数，这样框架就能正确地解析： @Controller public class GetUserWithPrincipalController { @RequestMapping(value = "/username", method = RequestMethod.GET) @ResponseBody public String currentUserName(Principal principal) { return principal.getName(); } } 或者，也可以使用 Authentication Token： @Controller public class GetUserWithAuthenticationController { @RequestMapping(value = "/username", method = RequestMethod. https://springdoc.cn/httpclient-ssl/ Sat, 30 Dec 2023 10:26:38 +0800 https://springdoc.cn/httpclient-ssl/ 1、概览 本文将带你了解如何配置 Apache HttpClient 4 和 5 以支持 “Accept All”（接受所有）SSL。目标很简单 - 信任所有证书，包括无效的 SSL 证书。 2、SSLPeerUnverifiedException 如果不在 HttpClient 上配置 SSL，下面的测试（使用 HTTPS URL）就会失败： @Test void whenHttpsUrlIsConsumed_thenException() { String urlOverHttps = "https://localhost:8082/httpclient-simple"; HttpGet getMethod = new HttpGet(urlOverHttps); assertThrows(SSLPeerUnverifiedException.class, () -> { CloseableHttpClient httpClient = HttpClients.createDefault(); HttpResponse response = httpClient.execute(getMethod, new CustomHttpClientResponseHandler()); assertThat(response.getCode(), equalTo(200)); }); } 确切的异常是： javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated at sun.security.ssl.SSLSessionImpl.getPeerCertificates(SSLSessionImpl.java:397) at org.apache.http.conn.ssl.AbstractVerifier.verify(AbstractVerifier.java:126) ... 如果无法为 URL 建立有效的信任链（Trust Chain），就会出现 javax.net.ssl.SSLPeerUnverifiedException 异常。 3、配置 SSL - Accept All（HttpClient 5） 现在，配置 HTTP 客户端信任所有证书链，无论其是否有效： https://springdoc.cn/exception-handling-for-rest-with-spring/ Fri, 29 Dec 2023 13:16:14 +0800 https://springdoc.cn/exception-handling-for-rest-with-spring/ 1、概览 本文将地带你了解如何在 Spring 中为 REST API 实现异常处理。 在 Spring 3.2 之前，在 Spring MVC 应用中处理异常的两种主要方法是 HandlerExceptionResolver 或 @ExceptionHandler 注解。这两种方法都有一些明显的缺点。 自 3.2 以来，可以使用 @ControllerAdvice 注解来解决前两种解决方案的局限性，并促进整个应用中统一的异常处理。 Spring 5 引入了 ResponseStatusException 类，一种在 REST API 中进行基本错误处理的快速方法。 所有这些都有一个共同点：它们都很好地处理了关注点的分离。应用通常可以抛出异常来表示某种失败，然后再单独进行处理。 2、解决方案 1：Controller 级的 @ExceptionHandler 第一种解决方案适用于 @Controller 层面。定义一个处理异常的方法，并用 @ExceptionHandler 进行注解： public class FooController{ //... @ExceptionHandler({ CustomException1.class, CustomException2.class }) public void handleException() { // } } 这种方法有一个很大的缺点：@ExceptionHandler 注解方法仅对特定 Controller 有效，而不是对整个应用全局有效。当然，可以将其添加到每个 Controller 中，但这并不适合作为通用的异常处理机制。 也可以通过让所有 Controller 都继承一个 Base Controller 类来绕过这一限制。 然而，对于某些原因无法实现上述方法的应用来说，这种解决方案可能会成为一个问题。例如，Controller 可能已经从另一个 Base 类继承而来，而该 Base 类可能在另一个 Jar 中或不可直接修改，或者 Controller 本身不可直接修改。 https://springdoc.cn/spring-scheduled-tasks/ Fri, 29 Dec 2023 11:35:02 +0800 https://springdoc.cn/spring-scheduled-tasks/ 1、概览 本文将带你了解如何使用 Spring @Scheduled 注解来配置和调度定时任务。 使用 @Scheduled 对方法进行注解时，需要遵循如下简单的规则： 方法的返回类型通常应为 void（如果不是，返回值将被忽略） 方法不应有任何参数 2、启用定时调度 可以在配置类上使用 @EnableScheduling 注解来启用 Spring 中的定时任务和 @Scheduled 注解的支持： @Configuration @EnableScheduling public class SpringConfig { ... } 也可以在 XML 中启用，如下： <task:annotation-driven> 3、以固定延迟调度任务 配置一个任务，使其在固定延迟后运行： @Scheduled(fixedDelay = 1000) public void scheduleFixedDelayTask() { System.out.println( "Fixed delay task - " + System.currentTimeMillis() / 1000); } 如上，上一次执行结束与下一次执行开始之间的持续时间是固定的。任务会一直等待到前一个任务结束。 在必须确保上一次执行完成后再次运行的情况下，应使用此选项。 4、以固定频率调度任务 在固定的时间间隔内执行一项任务： @Scheduled(fixedRate = 1000) public void scheduleFixedRateTask() { System.out.println( "Fixed rate task - " + System.currentTimeMillis() / 1000); } 如果任务的每次执行都是独立的，则应使用该选项。 https://springdoc.cn/spring-data-query-definitions-spel/ Fri, 29 Dec 2023 10:37:14 +0800 https://springdoc.cn/spring-data-query-definitions-spel/ 1、概览 SpEL 是 Spring Expression Language（Spring 表达式语言）的缩写，它是一种强大的工具，能显著增强与 Spring 的交互，并为配置、属性设置和查询操作提供额外的抽象。 本文将带你了解如何使用该工具使自定义查询更具动态性，通过 @Query 注解，可以使用 JPQL 或原生 SQL 来定制与数据库的交互。 2、访问参数 首先先看看如何使用 SpEL 处理方法参数。 2.1、通过索引访问 通过索引访问参数并不是最佳选择，因为这可能会给代码带来难以调试的问题。尤其是当参数类型相同时。 同时，这也提供了更大的灵活性，特别是在开发阶段，当参数的名称经常发生变化时。IDE 可能无法正确处理代码和查询的更新。 JDBC 提供了 ? 占位符，可以用它来确定参数在查询中的位置。Spring 支持这一约定，并允许以如下方式来访问参数： @Modifying @Transactional @Query(value = "INSERT INTO articles (id, title, content, language) " + "VALUES (?1, ?2, ?3, ?4)", nativeQuery = true) void saveWithPositionalArguments(Long id, String title, String content, String language); 到目前为止，使用的方法与之前在 JDBC 应用中使用的方法相同。注意，在数据库中进行更改的任何查询都需要 @Modifying 和 @Transactional 注解，INSERT 就是其中之一。所有 INSERT 的示例都将使用原生查询，因为 JPQL 不支持。 https://springdoc.cn/spring-profiles/ Thu, 28 Dec 2023 12:23:27 +0800 https://springdoc.cn/spring-profiles/ 1、概览 本文将带你了解 Spring 中的 Profile（配置文件），这是 Spring 的核心功能之一。可以把 Bean 配置在不同的 Profile，例如：dev、test、prod。然后，可以在不同的环境中激活指定的 Profile，以便只加载当前环境所需的 Bean。 2、在 Bean 上使用 @Profile 从简单的开始，看看如何使用 @Profile 注解将 Bean 映射到特定的 Profile。 该注解接受一个（或多个） Profile 名称。 考虑一个场景：有一个 Bean，它只能在开发过程中激活，不能在生产过程中部署。 用 dev Profile 注解该 Bean，它只会在开发环境中被加载到容器。在生产环境中， dev Profile 不会被激活： @Component @Profile("dev") public class DevDatasourceConfig Profile 名称也可以用 NOT 运算符作为前缀，如 !dev，以将其从 Profile 排除。 在如下示例中，只有当 dev Profile 未激活时，组件才会被激活： @Component @Profile("!dev") public class DevDatasourceConfig 3、在 XML 中声明 Profile Profile 也可以用 XML 配置。<beans> 标签有一个 profile 属性，该属性包含以逗号分隔的 Profile 值： <beans profile="dev"> <bean id="devDatasourceConfig" class="org. https://springdoc.cn/using-java-records-with-spring-boot/ Thu, 28 Dec 2023 10:38:48 +0800 https://springdoc.cn/using-java-records-with-spring-boot/ 本文将带你了解如何在 Spring Boot 应用中利用 Java Record 来提高其效率和可读性。 Java Record 是什么？ Java Record 是一种专为保存不可变数据而设计的类。它们自动提供 equals()、hashCode() 和 toString() 等方法的实现，大大减少了模板代码。因此，它们非常适合在 Spring Boot 应用中创建数据传输对象（DTO）、实体和其他模型类。 Java Record 示例 举一个简单的例子，用 Java Record 来表示一个 Person。 public record Person(String name, int age) {} 在本例中，Person 是一个 Record，包含两个字段：name 和 age。Java 自动为该 Record 提供了以下内容： 一个 public 构造函数：Person(String name, int age) 属性的 public Getter 方法：name() 和 age() 实现了 equals()、hashCode() 和 toString() 方法 使用 Getter 方法 Record 的主要特点之一是提供了用于访问字段的隐式 Getter 方法。这些方法以字段本身命名。 创建 Person 实例并使用其 Getter 方法： https://springdoc.cn/the-life-cycle-of-a-spring-bean/ Thu, 28 Dec 2023 10:20:51 +0800 https://springdoc.cn/the-life-cycle-of-a-spring-bean/ “讲一讲 Spring Bean 的生命周期”，这算是一道非常经典的面试题了！ 如果没有研究过 Spring 源码，单纯去背面试题，这个问题也是可以回答出来的，但是单纯的背缺乏理解，而且面试一紧张，就容易背岔了。 在前面的文章中，给大家分析了 Spring 中 Bean 的创建是在 createBean 方法中完成的。在该方法中，真正干活的实际上是 doCreateBean 方法，具体位置在 AbstractAutowireCapableBeanFactory#doCreateBean，大家在面试时候常被问到的 Spring Bean 的生命周期，实际上就是问 doCreateBean 方法的执行逻辑。 doCreateBean 方法整体上来说，干了四件事： Bean 的实例化。 Bean 属性填充。 Bean 初始化。 Bean 销毁方法注册。 这里大家注意区分 实例化 和 初始化 两个方法，实例化是指通过反射创建出来 Bean 实例的过程，而初始化则是调用一些回调函数进行 Bean 的一些预处理。 1、实例化 // Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { instanceWrapper = createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper. https://springdoc.cn/spring-state-machine-guides/ Wed, 27 Dec 2023 14:36:27 +0800 https://springdoc.cn/spring-state-machine-guides/ 说起 Spring 状态机，大家很容易联想到这个状态机和设计模式中状态模式的区别是啥呢？没错，Spring 状态机就是状态模式的一种实现，在介绍 Spring 状态机之前，让我们先来看看设计模式中的状态模式。 1、状态模式 状态模式的定义如下： 状态模式（State Pattern） 是一种行为型设计模式，它允许对象在内部状态发生变化时改变其行为。在状态模式中，一个对象的行为取决于其当前状态，而且可以随时改变这个状态。状态模式将对象的状态封装在不同的状态类中，从而使代码更加清晰和易于维护。当一个对象的状态改变时，状态模式会自动更新该对象的行为，而不需要在代码中手动进行判断和处理。 通常业务系统中会存在一些拥有状态的对象，而且这些状态之间可以进行转换，并且在不同的状态下会表现出不同的行为或者不同的功能，比如交通灯控制系统中会存在红灯、绿灯和黄灯，再比如订单系统中的订单会存在已下单、待支付、待发货、待收货等状态，这些状态会通过不同的行为进行相互转换，这时候在系统设计时就可以使用状态模式。 下面是 状态模式 的类图： 可以看到状态模式主要包含三种类型的角色： 上下文（Context）：封装了状态的实例，负责维护状态实例，并将请求委托给当前的状态对象。 抽象状态（State）：定义了表示不同状态的接口，并封装了该状态下的行为。所有具体状态都实现这个接口。 具体状态（Concrete State）：具体实现了抽象状态角色的接口，并封装了该状态下的行为。 下面是使用状态模式实现 红绿灯 状态变更的一个简单案例： 抽象状态类： /** * @description: 抽象状态类 */ public abstract class MyState { abstract void handler(); } 具体状态类 A： /** * @description: 具体状态A */ public class RedLightState extends MyState{ @Override void handler() { System.out.println("红灯停"); } } 具体状态类 B： /** * @description: 具体状态B */ public class GreenLightState extends MyState{ @Override void handler() { System. https://springdoc.cn/role-and-privilege-for-spring-security-registration/ Wed, 27 Dec 2023 11:22:58 +0800 https://springdoc.cn/role-and-privilege-for-spring-security-registration/ 1、概览 本文将带你了解如何在 Spring Security 中正确地实现 角色（Role） 和 权限（Privilege）。 2、用户、角色和权限 有如下 3 个实体： User：代表用户 Role：代表用户在系统中的高级角色。每个角色都有一组低级权限。 Privilege：代表系统中较低级别的、细粒度的特权/权限。 User 如下： @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; private String firstName; private String lastName; private String email; private String password; private boolean enabled; private boolean tokenExpired; @ManyToMany @JoinTable( name = "users_roles", joinColumns = @JoinColumn( name = "user_id", referencedColumnName = "id"), inverseJoinColumns = @JoinColumn( name = "role_id", referencedColumnName = "id")) private Collection<Role> roles; } 如上，用户包含角色和一些额外的细节，这些细节对于适当的注册机制来说是必要的。 https://springdoc.cn/spring-cache-tutorial/ Wed, 27 Dec 2023 10:22:41 +0800 https://springdoc.cn/spring-cache-tutorial/ 1、缓存抽象 本文将带你了解如何使用 Spring Cache 来提高系统性能。 2、开始使用 Spring 提供的核心缓存抽象位于 spring-context 模块中。 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.3</version> </dependency> 另外，还有一个名为 spring-context-support 的模块，它位于 spring-context 模块之上，并提供了更多由 EhCache 或 Caffeine 支持的 CacheManager。如果想使用这些模块作为缓存存储，则需要使用 spring-context-support 模块： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId> <version>5.3.3</version> </dependency> 由于 spring-context-support 模块临时依赖于 spring-context 模块，因此 spring-context 不需要单独的依赖声明。 2.1、Spring Boot 如果是 Spring Boot 项目，可以利用 spring-boot-starter-cache Starter 来轻松添加缓存依赖项： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> <version>2.4.0</version> </dependency> 该 Starter 包含了 spring-context-support 模块。 3、启用缓存 只需在任何配置类中添加 @EnableCaching 注解，即可启用缓存功能： @Configuration @EnableCaching public class CachingConfig { @Bean public CacheManager cacheManager() { return new ConcurrentMapCacheManager("addresses"); } } 当然，也可以通过 XML 配置来启用缓存： https://springdoc.cn/spring-autowire/ Tue, 26 Dec 2023 12:11:04 +0800 https://springdoc.cn/spring-autowire/ 1、概览 从 Spring 2.5 开始，框架引入了注解驱动的依赖注入功能。该功能的主要注解是 @Autowired 。它允许 Spring 解析并注入所依赖的 Bean 到 Bean 中。 本文将带你了解如何启用自动装配以及自动装配 Bean 的各种方法，以及如何使用 @Qualifier 注解来解决 Bean 冲突以及潜在的异常情况。 2、启用 @Autowired 注解 Spring 框架支持自动依赖注入。换句话说，通过在 Spring 配置文件中声明所有 Bean 的依赖关系，Spring 容器可以自动装配依赖 Bean 之间的关系。这就是所谓的 Spring Bean 自动装配。 首先启用注解驱动注入来加载 Spring 配置（基于 Java 的配置）： @Configuration @ComponentScan("com.baeldung.autowire.sample") public class AppConfig {} <context:annotation-config> 主要用于激活 Spring XML 文件中的依赖注入注解。 Spring Boot 还引入了 @SpringBootApplication 注解。这个注解相当于使用 @Configuration、@EnableAutoConfiguration 和 @ComponentScan。 在应用的 main 类中使用这个注解： @SpringBootApplication public class App { public static void main(String[] args) { SpringApplication. https://springdoc.cn/spring-cloud-configuration/ Tue, 26 Dec 2023 10:46:43 +0800 https://springdoc.cn/spring-cloud-configuration/ 1、概览 Spring Cloud Config 是 Spring 用于在分布式环境下提供集中式配置的解决方案。 本文将带你了解如何设置一个基于 Git 的配置服务器（包括加密的属性值），以及如何在 REST 应用中使用它。 2、依赖 首先是配置服务器应用，包含了 spring-cloud-config-server、spring-boot-starter-security 和 spring-boot-starter-web Starter： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-config-server</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> 然后是客户端应用，只需要 spring-cloud-starter-config 和 spring-boot-starter-web 模块： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-config</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> 3、实现配置服务器 通过在 @SpringBootApplication 类上注解 @EnableConfigServer 来启用配置服务器。该注解会自动配置所有必要的组件： @SpringBootApplication @EnableConfigServer public class ConfigServer { public static void main(String[] arguments) { SpringApplication.run(ConfigServer.class, arguments); } } 还需要配置服务器的监听端口和 Git URL（提供版本控制的配置内容）。后者可以使用诸如 http、ssh 或本地文件系统上的简单文件等协议。 https://springdoc.cn/spring-security-custom-filter/ Tue, 26 Dec 2023 10:21:25 +0800 https://springdoc.cn/spring-security-custom-filter/ 1、概览 本文将带你了解如何在 Spring Security Filter Chain（过滤器链）中定义一个自定义过 Filter（过滤器）。 2、创建 Filter Spring Security 默认提供了许多 Filter，这些 Filter 在大多数情况下已经足够。 当然，有时也需要在链中创建一个新的 Filter 来实现新功能。 首先，可以实现 org.springframework.web.filter.GenericFilterBean。 GenericFilterBean 是一个简单的 javax.servlet.Filter 实现，它还实现了一系列的 Aware 接口，可以感知到 Spring 容器中的一些组件。 只需实现一个方法： public class CustomFilter extends GenericFilterBean { @Override public void doFilter( ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { chain.doFilter(request, response); } } 3、在 Security Config 中配置 Filter 可以通过 XML 或 Java 配置把 Filter 配置到 Spring Security Filter Chain 中。 https://springdoc.cn/spring-value-annotation/ Mon, 25 Dec 2023 13:53:36 +0800 https://springdoc.cn/spring-value-annotation/ 1、概览 本文将带你了解 Spring 中的 @Value 注解。它用于向 Spring 管理的 Bean 中的字段注入值，可在字段或构造函数/方法上注解。 2、应用设置 创建一个简单的 Spring 应用来介绍该注解的不同用法。 首先，在 Properties 文件中定义想用 @Value 注解注入的值。 Properties 文件如下： value.from.file=Value got from the file priority=high listOfValues=A,B,C 然后，在配置类中定义一个 @PropertySource，指定 Properties 文件的名称以导入该 Properties 文件。 3、示例 通过注解注入 String（这种行为完全是多此一举，这里只是为了演示）： @Value("string value") private String stringValue; 使用 @PropertySource 注解导入了 Properties 文件后，就可以使用 @Value 注解处理 Properties 文件中的值。 如下，注入 value.from.file 属性值： @Value("${value.from.file}") private String valueFromFile; 也可以使用相同的语法从系统属性中设置值。 假设定义了一个名为 systemValue 的系统属性，如下： @Value("${systemValue}") private String systemValue; 可以给未定义的属性提供默认值，如下： @Value("${unknown.param:some default}") private String someDefault; 如果同一个属性在系统属性和 Properties 文件中都被定义了，那么系统属性将会生效。 https://springdoc.cn/configuration-properties-in-spring-boot/ Mon, 25 Dec 2023 09:55:31 +0800 https://springdoc.cn/configuration-properties-in-spring-boot/ 1、简介 Spring Boot 有许多有用的功能，包括外部化配置和轻松访问 Properties 文件中定义的属性。上一篇文章 介绍了实现这一点的各种方法。 本文将带你了解 Spring Boot 中的 @ConfigurationProperties 注解。 2、项目设置 按照惯例，在 pom.xml 中将 spring-boot-starter-parent 添加为 <parent>： <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>3.0.0</version> <relativePath/> </parent> 为了验证文件中定义的属性，还需要一个 JSR-380 实现，hibernate-validator 就是其中之一，它由 spring-boot-starter-validation 依赖提供。 把它也添加到 pom.xml 中： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validation</artifactId> </dependency> 更多详细信息可参阅 Hibernate Validator 入门。 3、示例属性 官方文档建议将配置属性隔离到单独的 POJO 中。 如下： @Configuration @ConfigurationProperties(prefix = "mail") public class ConfigProperties { private String hostName; private int port; private String from; //Get、Set 方法 } 通过 @Configuration 注解，Spring 会在 Application Context 中创建一个 Spring Bean。 https://springdoc.cn/properties-with-spring/ Mon, 25 Dec 2023 09:52:54 +0800 https://springdoc.cn/properties-with-spring/ 1、概览 本文将带你了解如何通过 Java 配置和 @PropertySource 在 Spring 中设置和使用 Properties，以及 Properties 在 Spring Boot 中的工作原理。 2、通过注解注册 Properties 文件 Spring 3.1 引入了新的 @PropertySource 注解，作为一种方便的机制，用于将属性源添加到环境中。 可以将此注解与 @Configuration 注解结合使用： @Configuration @PropertySource("classpath:foo.properties") public class PropertiesWithJavaConfig { //... } 另一种非常有用的注册新 Properties 文件的方法是使用占位符，它允许在运行时动态选择不同的文件： @PropertySource({ "classpath:persistence-${envTarget:mysql}.properties" }) ... 2.1、定义多个属性位置 @PropertySource 注解是可重复的（Java 8 的可重复注解特性）。因此，如果使用的是 Java 8 或更高版本，就可以使用此注解来定义多个属性位置： @PropertySource("classpath:foo.properties") @PropertySource("classpath:bar.properties") public class PropertiesWithJavaConfig { //... } 当然，也可以使用 @PropertySources 注解并指定一个 @PropertySource 数组。这不仅适用于 Java 8 或更高版本，也适用于任何受支持的 Java 版本： @PropertySources({ @PropertySource("classpath:foo.properties"), @PropertySource("classpath:bar.properties") }) public class PropertiesWithJavaConfig { //. https://springdoc.cn/spring-boot-testing/ Sun, 24 Dec 2023 13:40:23 +0800 https://springdoc.cn/spring-boot-testing/ 1、概览 本文将带你了解如何使用 Spring Boot 中的框架支持来编写测试，包括可以独立运行的单元测试，以及在执行测试之前加载 Spring Application Context 的集成测试。 2、项目设置 本文中的示例项目是一个 “雇员管理 API”，提供了对 Employee 资源的一些操作。是一个典型的MVC三层架构，从 Controller 到 Service 最后到持久层。 3、Maven 依赖 首先，添加测试依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> <version>2.5.0</version> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>test</scope> </dependency> spring-boot-starter-test 是主要的依赖，它包含了测试所需的大部分依赖。 H2 DB 是内存数据库，非常方便用于测试。 3.1、JUnit 4 从 Spring Boot 2.4 开始，JUnit 5 的 Vintage 引擎已从 spring-boot-starter-test 中移除。如果仍想使用 JUnit 4 编写测试，则需要添加以下 Maven 依赖： <dependency> <groupId>org.junit.vintage</groupId> <artifactId>junit-vintage-engine</artifactId> <scope>test</scope> <exclusions> <exclusion> <groupId>org.hamcrest</groupId> <artifactId>hamcrest-core</artifactId> </exclusion> </exclusions> </dependency> 4、使用 @SpringBootTest 进行集成测试 顾名思义，集成测试的重点是集成应用的不同层。这也意味着不涉及模拟（Mock）。 https://springdoc.cn/spring-boot-wirte-response-impact-responsenody/ Sat, 23 Dec 2023 15:57:01 +0800 https://springdoc.cn/spring-boot-wirte-response-impact-responsenody/ 问题回溯 2023 年 Q2 某日运营反馈一个问题，商品系统商家中心某批量工具模板无法下载，导致功能无法使用（因为模板是动态变化的） 商家中心报错如下（JSON串）： {"code":-1,"msg":"失败"} 负责的同事看到失败后立即与我展开讨论（因为不是关键业务，所以不需要回滚，修复即可），我们发现新功能模板下载的代码与之前的代码有所不同，恰好之前的功能又可以正常运行，所以同事对现有代码进行改造然后预发布测试完成后再次上线。 其他业务代码： /** * 模板下载 */ @RequestMapping("/doBatchWareSetAd") public void doBatchWareSetAd(@RequestParam MultipartFile file, HttpServletResponse response) { wareBatchBusiness.doBatchWareSetAd(file, response, getLongOrgCode(), getCurrentUserPin(), getCurrentUserId()); } 上线的结果是：仍然无法使用。 其实也正常：因为两种代码在预发布都可以正常运行，在线上出错只可能是因为其他原因，只不过我们不了解底层原理，害怕它 “可能” 有问题罢了，最终查询得到的结论是权限系统管理员在线上环境没有给我们配置相应的文件，导致请求为空，导致请求失败。 探索 @ResponseBody 与主动写入响应流的关系 我们都知道 @ResponseBody 注解可以帮助我们把返回对象转化为 JSON，方便展示和交互。 那它到底是如何工作的呢，请看下面的讲解： 代码案例 1 @RequestMapping("/test1") @ResponseBody public Map<String, String> test1(HttpServletResponse response) { Map<String, String> map = new HashMap<>(); map.put("1", "1"); return map; } // 响应 JSON报文 Debug 代码，发现其核心处理类为：RequestResponseBodyMethodProcessor。 方法：org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor#handleReturnValue 会处理其相关返回值。 真正的核心处理方法：org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor#writeWithMessageConverters。 关键 DEBUG 记录如下图所示： https://springdoc.cn/spring-security-5-oauth2-login/ Sat, 23 Dec 2023 10:25:07 +0800 https://springdoc.cn/spring-security-5-oauth2-login/ 1、概览 Spring Security 5 开始，引入了一个新的 OAuth2LoginConfigurer 类，可以用它来配置外部授权服务器（Authorization Server）。 本文主要带你了解 oauth2Login() 方法的一些可用配置选项。 2、Maven 依赖 在 Spring Boot 项目中，只需添加 spring-boot-starter-oauth2-client Starter 即可： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-oauth2-client</artifactId> <version>2.3.3.RELEASE</version> </dependency> 在非 Spring Boot 项目中，除了标准的 Spring 和 Spring Security 依赖外，还需要显式添加 spring-security-oauth2-client 和 spring-security-oauth2-jose 依赖： <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-oauth2-client</artifactId> <version>5.3.4.RELEASE</version> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-oauth2-jose</artifactId> <version>5.3.4.RELEASE</version> </dependency> 3、客户端设置 在 Spring Boot 项目中，只需为每个要配置的客户端添加几个标准属性即可。 接下来，我们要配置使用 Google 和 Facebook 作为 Authentication Provider 注册的客户端登录。 3.1、获取客户端凭证 要获取 Google OAuth2 身份认证的客户端凭证，请访问 Google API 控制台 的 “Credentials” 部分。 https://springdoc.cn/spring-security-method-security/ Fri, 22 Dec 2023 11:45:38 +0800 https://springdoc.cn/spring-security-method-security/ 1、概览 简而言之，Spring Security 支持方法级别的授权语义。可以通过限制哪些角色可以执行特定方法等方式来确保 Service 层的安全。 2、启用 Method Security 要使用 Spring Method Security，需要添加 spring-security-config 依赖： <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-config</artifactId> </dependency> 可以在 Maven Central 上找到它的最新版本。 如果使用的是 Spring Boot，可以添加 spring-boot-starter-security 依赖，其中包括 spring-security-config： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> 同样，它的最新版本也可以在 Maven Central 中找到。 接下来，需要启用全局 Method Security： @Configuration @EnableGlobalMethodSecurity( prePostEnabled = true, securedEnabled = true, jsr250Enabled = true) public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration { } prePostEnabled 属性可启用 Spring Security Pre/Post 注解。 securedEnabled 属性决定是否启用 @Secured 注解。 jsr250Enabled 属性允许使用 @RoleAllowed 注解。 3、应用 Method Security 3. https://springdoc.cn/spring-response-entity/ Fri, 22 Dec 2023 11:17:48 +0800 https://springdoc.cn/spring-response-entity/ 1、概览 本文将带你了解如何使用 ResponseEntity 设置 HTTP 响应的 Body、Status 和 Header。 2、ResponseEntity ResponseEntity 表示整个 HTTP 响应：状态码、Header 和 Body。因此，可以用它来完全配置 HTTP 响应。只需从端点返回它，Spring 就会处理接下来的所有事情。 ResponseEntity 是一个泛型类。因此，可以使用任何类型作为响应体： @GetMapping("/hello") ResponseEntity<String> hello() { return new ResponseEntity<>("Hello World!", HttpStatus.OK); } 通过编程式，可以针对不同情况返回不同的 HTTP 状态码： @GetMapping("/age") ResponseEntity<String> age( @RequestParam("yearOfBirth") int yearOfBirth) { if (isInFuture(yearOfBirth)) { return new ResponseEntity<>( "Year of birth cannot be in the future", HttpStatus.BAD_REQUEST); // 400 } return new ResponseEntity<>( "Your age is " + calculateAge(yearOfBirth), HttpStatus.OK); // 200s } 还可以设置 HTTP 响应头： https://springdoc.cn/spring-boot-logging/ Fri, 22 Dec 2023 09:59:09 +0800 https://springdoc.cn/spring-boot-logging/ 1、概览 本文将带你了解 Spring Boot 应用中的日志配置。 2、初始设置 通过 Spring Initializr 初始化一个 Spring Boot 应用： 创建唯一的类 LoggingController： @RestController public class LoggingController { Logger logger = LoggerFactory.getLogger(LoggingController.class); @RequestMapping("/") public String index() { logger.trace("A TRACE Message"); logger.debug("A DEBUG Message"); logger.info("An INFO Message"); logger.warn("A WARN Message"); logger.error("An ERROR Message"); return "Howdy! Check out the Logs to see the output..."; } } 启动应用后，只需访问 http://localhost:8080/，就能触发这些日志输出。 3、日志零配置 就日志记录而言，Spring Boot 唯一必须的依赖是 Apache Commons Logging。它是由 Spring 的 spring-jcl 模块提供的。 如果使用的是 Spring Boot Starter（几乎总是使用 Spring Boot Starter），就根本不用担心导入 spring-jcl 的问题。这是因为每个 Starter，比如 spring-boot-starter-web，都依赖于 spring-boot-starter-logging，它已经导入了 spring-jcl。 https://springdoc.cn/spring-request-param/ Thu, 21 Dec 2023 13:45:18 +0800 https://springdoc.cn/spring-request-param/ 1、概览 本文将带你了解 Spring 中 @RequestParam 注解的用法。 简单地说，可以使用 @RequestParam 从请求中提取查询参数、表单参数甚至是多个参数。 2、示例端点 假设我们有一个端点 /api/foos，它接受一个名为 id 的查询参数： @GetMapping("/api/foos") @ResponseBody public String getFoos(@RequestParam String id) { return "ID: " + id; } 在本例中，使用 @RequestParam 来提取 id 查询参数。 通过 GET 请求来调用 getFoos： http://localhost:8080/spring-mvc-basics/api/foos?id=abc ---- ID: abc 接下来，看看注解的属性：name、value、required 和 defaultValue。 3、指定请求参数名称 在上一个示例中，变量名和参数名都是相同的。 如果变量名称和参数名称不同，可以使用 name 属性配置 @RequestParam 名称： @PostMapping("/api/foos") @ResponseBody public String addFoo(@RequestParam(name = "id") String fooId, @RequestParam String name) { return "ID: " + fooId + " Name: " + name; } 也可以使用 @RequestParam(value = "id") 或直接使用 @RequestParam("id")。 https://springdoc.cn/spring-boot-bean-validation/ Thu, 21 Dec 2023 13:10:51 +0800 https://springdoc.cn/spring-boot-bean-validation/ 1、概览 Spring Boot 通过 Hibernate Validator（Bean Validation 的实现）对数据验证提供了强大的支持。 本文将通过一个实际的 REST 应用带你了解如何在 Spring Boot 中校验数据。 2、Maven 依赖 在 pomx.ml 中添加 spring-boot-starter-web、spring-boot-starter-jpa 和 H2 database 依赖： <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>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.1.214</version> <scope>runtime</scope> </dependency> 从 Boot 2.3 开始，还需要明确添加 spring-boot-starter-validation 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validation</artifactId> </dependency> 3、示例 Domain 类 定义一个 JPA 实体类，User： @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.AUTO) private long id; @NotBlank(message = "Name is mandatory") private String name; @NotBlank(message = "Email is mandatory") private String email; // 构造函数、Set、Set 方发省略 } User 实体类很简单，它展示了如何使用 Bean Validation 的约束来限制 name 和 email 字段。 https://springdoc.cn/spring-data-jpa-last-record/ Thu, 21 Dec 2023 12:50:44 +0800 https://springdoc.cn/spring-data-jpa-last-record/ 1、概览 本文将带你了解使用 Spring Data JPA 获取最后一条记录的多种方式。 2、初始设置 首先，创建并初始化要查询的表。 创建一个 Post 实体类： @Entity public class Post { @Id private Long id; private String title; private LocalDate publicationDate; // get、set 方法 } @Entity 表示注解的类代表数据库中的一个表。@Id 注解定义了主键。 为了简单起见，这里使用的是 H2 内存数据库。 添加一个基本的 SQL 脚本，创建 Post 类对应的 post 表： DROP TABLE IF EXISTS post; CREATE TABLE post( id INT PRIMARY KEY, title VARCHAR(200), publication_date DATE ) 接着，添加一些数据： INSERT INTO post (id, title, publication_date) VALUES(1, 'Facebook post', '2020-11-10'); INSERT INTO post (id, title, publication_date) VALUES(2, 'Instagram post', '2020-12-24'); INSERT INTO post (id, title, publication_date) VALUES(3, 'Twitter post', '2023-01-10'); INSERT INTO post (id, title, publication_date) VALUES(4, 'tiktok post', '2023-03-18'); INSERT INTO post (id, title, publication_date) VALUES(5, 'Pinterest post', '2023-09-09'); 如你所见，最后一条记录的 ID 是 5。 https://springdoc.cn/spring-cloud-openfeign-guides/ Thu, 21 Dec 2023 11:13:30 +0800 https://springdoc.cn/spring-cloud-openfeign-guides/ 1、概览 本文将带你了解 Spring Boot 应用中的声明式 REST 客户端 - Spring Cloud OpenFeign。 Feign 通过可插拔的注解支持（包括 Feign 注解和 JAX-RS 注解）使编写 Web 客户端更加容易。 此外，Spring Cloud 还增加了对 Spring MVC 注解和使用与 Spring Web 中相同的 HttpMessageConverter 的支持。 使用 Feign 的一个好处是，除了接口定义外，无需编写任何调用服务的代码。 2、依赖 首先，创建 Spring Boot Web 项目，并在 pom.xml 文件中添加 spring-cloud-starter-openfeign 依赖： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> 此外，还需要添加 spring-cloud-dependencies 依赖： <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>${spring-cloud.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> 你可以在 Maven Central 上找到 spring-cloud-starter-openfeign 和 spring-cloud-dependencies 的最新版本。 3、Feign 客户端 接着，需要将 @EnableFeignClients 添加到 main 类中： https://springdoc.cn/spring-reloading-properties/ Thu, 21 Dec 2023 09:55:51 +0800 https://springdoc.cn/spring-reloading-properties/ 1、概览 本文将带你了解如何在 Spring 中重新加载 Properties 配置属性。 2、Spring 读取 Properties Spring 有几种不同的方式来访问 Properties： Environment - 可以注入 Environment，然后使用 Environment#getProperty 来读取给定的属性。Environment 包含不同的属性源，如系统属性（System Properties）、-D 参数和 application.properties（或者 .yml） 等。还可以使用 @PropertySource 将额外的属性源添加到 Environment 中。 Properties - 可以将 properties 文件加载到 Properties 实例中，然后在 Bean 中通过调用 properties.get("property") 使用它。 @Value - 可以使用 @Value(${'property'}) 注解在 Bean 中注入特定属性。 @ConfigurationProperties - 可以使用 @ConfigurationProperties 在 Bean 中加载层次化的属性。。 3、重新加载外部属性文件 要在运行时更改文件中的属性（Properties），应该将该文件放在 Jar 之外的某个地方。然后使用命令行参数 -spring.config.location=file://{文件路径} 告诉 Spring 文件的位置。或者，也可以将其放在 application.properties 中。 对于基于磁盘文件的 Properties，可以开发一个端点或定时任务来读取文件并更新 Properties。 Apache 的 commons-configuration 是一个用于重新加载属性文件的库。可以使用 PropertiesConfiguration 和不同的 ReloadingStrategy 。 https://springdoc.cn/spring-cloud-custom-gateway-filters/ Wed, 20 Dec 2023 14:55:58 +0800 https://springdoc.cn/spring-cloud-custom-gateway-filters/ 1、概览 上一篇文章《Spring Cloud Gateway 教程》中介绍了 Spring Cloud Gateway 网关框架。本文将带你了解如何在 Spring Cloud Gateway 中自定义 Filter。以及如何在 Filter 中修改请求和响应数据。 2、项目设置 创建一个基本应用，并将其用作 API 网关。 2.1、Maven 配置 在使用 Spring Cloud 时，往往通过 <dependencyManagement> 来管理组件的版本： <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>Hoxton.SR4</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> 添加 Spring Cloud Gateway，无需指定使用的实际版本： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-gateway</artifactId> </dependency> 最新的 Spring Cloud 版本可通过 Maven Central 中找到。当然，需要注意使用的 Spring Cloud 版本需要与 Spring Boot 版本兼容。 2.2、API 网关配置 假设 API 服务在本地 8081 端口运行，在 /resource 端点暴露了一个简单的字符串资源。 接下来，配置网关，把请求代理到该服务。简而言之，当请求网关的 URI 路径中带有 /service 前缀的请求时，网关将把请求转发给该服务。 https://springdoc.cn/java-reactor-webflux-vs-virtual-threads/ Wed, 20 Dec 2023 14:09:12 +0800 https://springdoc.cn/java-reactor-webflux-vs-virtual-threads/ 1、概览 本文将带你了解 Java 19 的 虚拟线程 和 Reactor Webflux 的基本工作原理以及它们的优缺点。 2、代码示例 假如我们开发的是一个电商后台，有如下 “负责计算和发布添加到购物车中的商品价格” 的函数。 class ProductService { private final String PRODUCT_ADDED_TO_CART_TOPIC = "product-added-to-cart"; private final ProductRepository repository; private final DiscountService discountService; private final KafkaTemplate<String, ProductAddedToCartEvent> kafkaTemplate; // 构造函数 public void addProductToCart(String productId, String cartId) { Product product = repository.findById(productId) .orElseThrow(() -> new IllegalArgumentException("not found!")); Price price = product.basePrice(); if (product.category().isEligibleForDiscount()) { BigDecimal discount = discountService.discountForProduct(productId); price.setValue(price.getValue().subtract(discount)); } var event = new ProductAddedToCartEvent(productId, price. https://springdoc.cn/spring-rest-with-zuul-proxy/ Wed, 20 Dec 2023 13:42:45 +0800 https://springdoc.cn/spring-rest-with-zuul-proxy/ 1、概览 本文将带你了解如何在 UI （前端）应用中使用 Zuul 作为代理与 Spring REST 服务通信，使用 Zuul 代理的目的是为了统一处理 CORS 和 Same Origin Policy 问题。 Zuul 是 Netflix 基于 JVM 的路由和服务器端负载均衡器。Spring Cloud 与嵌入式 Zuul 代理进行了很好的集成。 2、Maven 配置 首先，在 UI 应用的 pom.xml 中添加 Spring Cloud Zuul 依赖： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-zuul</artifactId> <version>2.2.0.RELEASE</version> </dependency> 最新版本可在 此处 找到。 3、Zuul Properties 接着，在 application.yml 中对 Zuul 进行配置： zuul: routes: foos: path: /foos/** url: http://localhost:8081/spring-zuul-foos-resource/foos 如上： 代理了资源服务器 Foos UI 应用上所有以 /foos/ 开头的请求都将转发到 Foos 资源服务器 http://loclahost:8081/spring-zuul-foos-resource/foos/ 4、API API 是一个简单的 Spring Boot 应用，监听 8081 端口。 https://springdoc.cn/spring-boot-h2-database/ Wed, 20 Dec 2023 11:03:08 +0800 https://springdoc.cn/spring-boot-h2-database/ 1、概览 本文将带你了解如何在 Spring Boot 中使用 H2 内存数据库。与其他数据库一样，Spring Boot 生态系统对 H2 提供了开箱即用的支持。 2、依赖 添加 h2 和 spring-boot-starter-data-jpa 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>runtime</scope> </dependency> 3、Datasource 配置 默认情况下，Spring Boot 会配置应用使用用户名 sa 和空密码连接到内存数据库。 不过，你也可以通过在 application.properties 文件中添加以下属性来更改这些参数： spring.datasource.url=jdbc:h2:mem:testdb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password=password spring.jpa.database-platform=org.hibernate.dialect.H2Dialect 相应的 YAML 配置如下： spring: datasource: url: jdbc:h2:mem:mydb username: sa password: password driverClassName: org.h2.Driver jpa: spring.jpa.database-platform: org.hibernate.dialect.H2Dialect 内存数据库会在应用重启后会丢失数据，可以通过使用基于文件的存储来改变这种行为。 更新 spring.datasource.url 属性： spring.datasource.url=jdbc:h2:file:/data/demo 相应的 YAML 配置如下： spring: datasource: url: jdbc:h2:file:/data/demo H2 数据库还可以在 其他模式 下运行。 https://springdoc.cn/spring-bean-annotations/ Wed, 20 Dec 2023 10:27:18 +0800 https://springdoc.cn/spring-bean-annotations/ 1、概览 本文将带你了解最常见的 Spring Bean 注解，用于定义不同类型的 Bean。 在 Spring 容器中配置 Bean 有几种方法。可以使用 XML 配置声明，也可以在配置类中使用 @Bean 注解声明 Bean。 最后，还可以使用 org.springframework.stereotype 包中的注解来标记类，然后由组件扫描来处理。 2、组件扫描 如果启用了组件扫描，Spring 就可以自动扫描包中的 Bean。 通过 @ComponentScan 注解配置要扫描的包，以查找带有注解配置的类。可以使用 basePackages 或 value 参数（value 是 basePackages 的别名）指定 base package： @Configuration @ComponentScan(basePackages = "com.baeldung.annotations") class VehicleFactoryConfig {} 还可以使用 basePackageClasses 参数指定 base package 中的类： @Configuration @ComponentScan(basePackageClasses = VehicleFactoryConfig.class) class VehicleFactoryConfig {} 这两个参数都是数组，因此可以为每个参数指定多个 package。 如果没有指定参数，将从 @ComponentScan 注解类所在的同一个包中开始扫描。 @ComponentScan 利用了 Java 8 的重复注解功能，这意味着可以多次使用它来标记一个类： @Configuration @ComponentScan(basePackages = "com.baeldung.annotations") @ComponentScan(basePackageClasses = VehicleFactoryConfig. https://springdoc.cn/spring-data-annotations/ Tue, 19 Dec 2023 14:49:40 +0800 https://springdoc.cn/spring-data-annotations/ 1、简介 Spring Data 提供了对数据存储技术的抽象。因此，我们的业务逻辑代码可以更加独立于底层持久化实现。而且，Spring 还简化了处理与数据存储相关的实现细节的过程。 本文将带你了解 Spring Data、Spring Data JPA 和 Spring Data MongoDB 项目中最常见的注解。 2、常见的 Spring Data 注解 2.1、@Transactional @Transactional 用于定义事务方法： @Transactional void pay() {} 如果在类上应用此注解，那么它就会对类中的所有方法起作用。也可以在方法上定义此注解来进行覆盖。 2.2、@NoRepositoryBean 有时我们会通过一个基本的 Repository 接口，定义一些通用的方法。然后，所有的 Repository 来继承这个基本的 Repository 接口。 基本的 Repository 接口不应该被实例化为 Bean，所以可以使用 @NoRepositoryBean 注解进行标注。 例如，如果想在所有 Repository 中使用 Optional<T> findById(ID id) 方法，那么可以创建一个基础 Repository 接口： @NoRepositoryBean interface MyUtilityRepository<T, ID extends Serializable> extends CrudRepository<T, ID> { Optional<T> findById(ID id); } 此注解不会影响子接口，因此 Spring 将会把下面 Repository 接口创建为 Bean： https://springdoc.cn/spring-scheduling-annotations/ Tue, 19 Dec 2023 14:34:55 +0800 https://springdoc.cn/spring-scheduling-annotations/ 1、概览 本文将带你了解 org.springframework.scheduling.annotation 包中和调度相关的注解。 2、@EnableAsync 注解用于在 Spring 中启用异步功能。 必须与 @Configuration 一起使用： @Configuration @EnableAsync class VehicleFactoryConfig {} 启用了异步调用后，可以使用 @Async 来定义支持异步调用的方法。 3、@EnableScheduling @EnableScheduling 用于启用定时任务调度。同样，必须与 @Configuration 结合使用： @Configuration @EnableScheduling class VehicleFactoryConfig {} 启用了定时调度后，就可以可以使用 @Scheduled 注解来定期运行方法。 4、@Async @Async 用于注解需要异步执行的方法。 @Async void repairCar() { // ... } 如果将此注解应用于一个类，那么所有方法都将被异步调用。 注意，需要通过 @EnableAsync 或 XML 配置来启用异步调用，此注解才会生效。 5、@Scheduled 如果需要定期执行一个方法，可以使用此注解： @Scheduled(fixedRate = 10000) void checkVehicle() { // ... } 可以使用它来按固定间隔执行方法，或者可以使用类似 cron 的表达式进行微调。 @Scheduled 利用了 Java 8 的重复注解功能，这意味着可以多次使用它来标记一个方法： @Scheduled(fixedRate = 10000) @Scheduled(cron = "0 * * * * MON-FRI") void checkVehicle() { // . https://springdoc.cn/spring-boot-annotations/ Tue, 19 Dec 2023 14:00:55 +0800 https://springdoc.cn/spring-boot-annotations/ 1、概览 Spring Boot 的自动配置功能让配置 Spring 变得更容易。 本文将带你了解 org.springframework.boot.autoconfigure 和 org.springframework.boot.autoconfigure.condition 包中的核心注解。 2、@SpringBootApplication 使用此注解来标记 Spring Boot 应用的 main 类： @SpringBootApplication class VehicleFactoryApplication { public static void main(String[] args) { SpringApplication.run(VehicleFactoryApplication.class, args); } } @SpringBootApplication 封装了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 注解，均为默认属性。 3、@EnableAutoConfiguration @EnableAutoConfiguration 顾名思义就是启用自动配置。这意味着 Spring Boot 会在其 classpath 上查找自动配置 Bean，并自动应用它们。 注意，必须将此注解与 @Configuration 一起使用： @Configuration @EnableAutoConfiguration class VehicleFactoryConfig {} 4、自动配置的条件注解 通常，在编写自定义自动配置时，我们希望 Spring 有条件地使用它们。这可以通过本节中的注解来实现这一目标。 可以将本节中的注解放在 @Configuration 类或 @Bean 方法上。 4.1、@ConditionalOnClass 和 @ConditionalOnMissingClass 只有注解参数中的类存在/不存在时，Spring 才会使用标记的自动配置 Bean： https://springdoc.cn/spring-mvc-annotations/ Tue, 19 Dec 2023 13:19:00 +0800 https://springdoc.cn/spring-mvc-annotations/ 1、概览 本文将带你了解 org.springframework.web.bind.annotation 包中的 Spring Web 注解。 2、@RequestMapping 简单地说，@RequestMapping 注解用于标记 @Controller 类中的请求处理方法（Handler），可配置的属性如下： path 或其别名 name 和 value：方法映射到的 URL method：支持的 HTTP 方法 params：内容协商，根据 HTTP 参数的有无或值匹配请求 headers：内容协商，根据 HTTP Header 的存在、缺失或值匹配请求 consumes：支持的请求媒体类型（Content-Type） produces：响应的媒体类型 示例如下： @Controller class VehicleController { @RequestMapping(value = "/vehicles/home", method = RequestMethod.GET) String home() { return "home"; } } 在 @Controller 类的类级应用此注解，就能为类中的所有 Handler 方法提供默认设置。唯一的例外是 URL，Spring 不会在方法级设置覆盖 URL，而是将两个 path 部分拼接在一起。 例如，以下配置与上述配置效果相同： @Controller @RequestMapping(value = "/vehicles", method = RequestMethod.GET) class VehicleController { @RequestMapping("/home") String home() { return "home"; } } 此外，@GetMapping、@PostMapping、@PutMapping、@DeleteMapping 和 @PatchMapping 是 @RequestMapping 的不同变体，其 HTTP 方法已分别设置为 GET、POST、PUT、DELETE 和 PATCH。 https://springdoc.cn/spring-core-annotations/ Tue, 19 Dec 2023 10:30:48 +0800 https://springdoc.cn/spring-core-annotations/ 1、概览 我们可以通过 org.springframework.beans.factory.annotation 和 org.springframework.context.annotation 包中的注解来使用 Spring DI 引擎的功能。 通常把这些注解称为 “Spring 核心注解”。 2、和 DI 相关的注解 2.1、@Autowired 可以在构造函数、Setter 方法或字段注入中使用 @Autowired 注解，Spring 会解析并注入依赖。 构造函数注入： class Car { Engine engine; @Autowired Car(Engine engine) { this.engine = engine; } } Setter 注入: class Car { Engine engine; @Autowired void setEngine(Engine engine) { this.engine = engine; } } 字段注入： class Car { @Autowired Engine engine; } @Autowired 有一个名为 required 的 boolean 参数，默认值为 true。当 Spring 找不到合适的 Bean 进行注入时，它会控制 Spring 的行为。当值为 true 时，会抛出异常，反之则不会。 https://springdoc.cn/rest-api-query-search-or-operation/ Mon, 18 Dec 2023 13:59:30 +0800 https://springdoc.cn/rest-api-query-search-or-operation/ 1、概览 本文将扩展 上一篇文章 中实现的高级搜索操作，在 REST API 查询语言中加入基于 OR 的搜索条件。 2、实现方法 以前，search 查询参数中的所有条件都是由 AND 运算符组成的条件。 现在，使用标志来指示必须使用 OR 运算符组合条件。 http://localhost:8080/users?search=firstName:john,'lastName:doe 注意，这里用单引号标记了条件 lastName，以示区别。我们会在条件值对象 SpecSearchCriteria 中捕获 OR 运算符的 Predicate： public SpecSearchCriteria( String orPredicate, String key, SearchOperation operation, Object value) { super(); this.orPredicate = orPredicate != null && orPredicate.equals(SearchOperation.OR_PREDICATE_FLAG); this.key = key; this.operation = operation; this.value = value; } 3、改进 UserSpecificationBuilder 修改 UserSpecificationBuilder，以在构建 Specification<User> 时考虑 OR 条件： public Specification<User> build() { if (params.size() == 0) { return null; } Specification<User> result = new UserSpecification(params. https://springdoc.cn/rest-api-query-search-language-more-operations/ Mon, 18 Dec 2023 13:21:34 +0800 https://springdoc.cn/rest-api-query-search-language-more-operations/ 1、概览 前面几篇文章介绍了三种 REST 查询语言的实现方式，分别是：JPA Criteria、Spring Data JPA Specification 和 QueryDSL。 本文将扩展前面几篇文章中开发的 REST 查询语言，使其包含更多搜索操作，如：等于、不等于、大于、小于、前缀、后缀、包含和类似（Like）。 本文选择使用 Specification，因为它是一种清晰而灵活的表示操作的方式。 2、SearchOperation 枚举 首先，通过枚举来更好地定义各种支持的搜索操作： public enum SearchOperation { EQUALITY, NEGATION, GREATER_THAN, LESS_THAN, LIKE, STARTS_WITH, ENDS_WITH, CONTAINS; public static final String[] SIMPLE_OPERATION_SET = { ":", "!", ">", "<", "~" }; public static SearchOperation getSimpleOperation(char input) { switch (input) { case ':': return EQUALITY; case '!': return NEGATION; case '>': return GREATER_THAN; case '<': return LESS_THAN; case '~': return LIKE; default: return null; } } } 有两组操作： https://springdoc.cn/rest-api-search-language-spring-data-querydsl/ Mon, 18 Dec 2023 12:32:44 +0800 https://springdoc.cn/rest-api-search-language-spring-data-querydsl/ 1、概览 在前两篇文章中，我们使用 JPA Criteria 和 Spring Data JPA Specification 构建了相同的搜索/过滤功能。 本文将带你了解如何使用 Spring Data JPA 和 Querydsl 构建 REST API 查询语言。 2、Querydsl 配置 首先，在 pom.xml 中添加以下依赖： <dependency> <groupId>com.querydsl</groupId> <artifactId>querydsl-apt</artifactId> <version>4.2.2</version> </dependency> <dependency> <groupId>com.querydsl</groupId> <artifactId>querydsl-jpa</artifactId> <version>4.2.2</version> </dependency> 还需要配置 APT（注解处理工具）插件： <plugin> <groupId>com.mysema.maven</groupId> <artifactId>apt-maven-plugin</artifactId> <version>1.1.3</version> <executions> <execution> <goals> <goal>process</goal> </goals> <configuration> <outputDirectory>target/generated-sources/java</outputDirectory> <processor>com.mysema.query.apt.jpa.JPAAnnotationProcessor</processor> </configuration> </execution> </executions> </plugin> 该插件会根据实体类生成 Q 开头的查询类。 关于如何在 Spring Boot 中使用 QueryDSL，你可以参阅 这篇文章。 3、MyUser 实体 定义 MyUser 实体，用于在 API 中进行搜索： @Entity public class MyUser { @Id @GeneratedValue(strategy = GenerationType. https://springdoc.cn/rest-api-search-language-spring-data-specifications/ Mon, 18 Dec 2023 11:06:23 +0800 https://springdoc.cn/rest-api-search-language-spring-data-specifications/ 1、概览 上一篇文章 介绍了一个基于 JPA Criteria 的查询语言解决方案。 本文将带你了解如何使用 Spring Data JPA 和 Specification 构建一个搜索/过滤 REST API。 2、 User 实体 创建一个 User 实体类，用于检索 API： @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; private String firstName; private String lastName; private String email; private int age; // get、set 方法 } 3、使用 Specification 进行过滤 来看看如何使用自定义 Spring Data JPA Specification 进行查询。 创建一个实现 Specification 接口的 UserSpecification，并传入自己的约束条件来构建实际查询： public class UserSpecification implements Specification<User> { private SearchCriteria criteria; @Override public Predicate toPredicate (Root<User> root, CriteriaQuery<? https://springdoc.cn/rest-search-language-spring-jpa-criteria/ Mon, 18 Dec 2023 10:19:44 +0800 https://springdoc.cn/rest-search-language-spring-jpa-criteria/ 1、概览 在接下来的一系列文章中，我将带你了解一种用于 REST API 的简单查询语言。 为什么要使用查询语言（Query Language）？因为对于任何足够复杂的 API 来说，仅仅通过简单的字段来搜索/过滤资源是远远不够的。查询语言更加灵活，可以准确过滤选出所需的资源。 2、User 实体 首先，创建一个 User 实体，用于在过滤/搜索 API 中使用： @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; private String firstName; private String lastName; private String email; private int age; } 3、使用 CriteriaBuilder 过滤 构建查询抽象是一个平衡问题。一方面，需要足够的灵活性，另一方面，需要保持可控的复杂性。高级查询的功能很简单 - 输入一些约束条件，然后得到一些结果。 来看看如何使用： @Repository public class UserDAO implements IUserDAO { @PersistenceContext private EntityManager entityManager; @Override public List<User> searchUser(List<SearchCriteria> params) { CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<User> query = builder. https://springdoc.cn/spring-kafka-trusted-packages-feature/ Sun, 17 Dec 2023 14:12:44 +0800 https://springdoc.cn/spring-kafka-trusted-packages-feature/ 1、概览 本文将带你了解 Spring Kafka 中的 “Trusted Packages” 功能，了解其背后的动机以及用法。 2、先决条件 一般来说，Spring Kafka 模块允许我们指定一些关于发送的 POJO 的元数据。它通常采用 Kafka Message Header 的形式。 例如，可以这样配置 ProducerFactory： @Bean public ProducerFactory<Object, SomeData> producerFactory() { JsonSerializer<SomeData> jsonSerializer = new JsonSerializer<>(); jsonSerializer.setAddTypeInfo(true); return new DefaultKafkaProducerFactory<>( producerFactoryConfig(), new StringOrBytesSerializer(), jsonSerializer ); } @Data @AllArgsConstructor static class SomeData { private String id; private String type; private String status; private Instant timestamp; } 然后，使用上面用 producerFactory 配置的 KafkaTemplate 在一个 Topic 中生产一条新消息： public void sendDataIntoKafka() { SomeData someData = new SomeData("1", "active", "sent", Instant. https://springdoc.cn/sso-spring-security-oauth2/ Sun, 17 Dec 2023 13:21:19 +0800 https://springdoc.cn/sso-spring-security-oauth2/ 1、概览 本文将带你了解如何使用 Spring Security OAuth 和 Spring Boot 以及 Keycloak 作为授权服务器来实现单点登录（SSO）。 我们会使用 4 个不同的应用： 授权服务器 - 中央认证机制 资源服务器 - Foo 资源的提供者 两个客户端应用 - 使用 SSO 的应用 简单地说，当用户试图通过一个客户端应用访问资源时，他们会被重定到授权服务器进行身份认证。Keycloak 会对用户进行登录，在登录第一个应用后，如果使用同一浏览器访问第二个客户端应用，用户无需再次输入凭据。 使用 OAuth2 的授权码（Authorization Code）模式。 Spring Security 将此功能称为 OAuth 2.0 登录，而 Spring Security OAuth 将其称为 SSO。 2、授权服务器 以前，通过 Spring Security OAuth 可以将授权服务器设置为 Spring 应用。 不过，Spring Security OAuth 已被 Spring 弃用，现在可以使用 Keycloak 作为授权服务器。 因此，这次我们在 Spring Boot 应用中把授权服务器设置为嵌入式 Keycloak 服务器。 在 预配置 中，我们将定义两个客户端，即 ssoClient-1 和 ssoClient-2，分别对应每个客户端应用。 https://springdoc.cn/sso-spring-security-oauth2-legacy/ Sun, 17 Dec 2023 11:49:04 +0800 https://springdoc.cn/sso-spring-security-oauth2-legacy/ 1、概览 本文将带你了解如何使用 Spring Security OAuth 和 Spring Boot 实现单点登录（SSO）。 我们会使用三个不同的应用： 授权服务器 - 中央认证机制 两个客户端应用：使用 SSO 的应用 简单来说，当用户试图访问客户端应用中受保护的页面时，他们会被重定向到过身份认证服务器进行身份验。使用 OAuth2 的 “授权码（Authorization Code）模式”。 注：本文使用的是 Spring OAuth 传统技术。如果你想查看新版 Spring Security 的版本，请参阅《使用 Spring Security OAuth2 实现 SSO 单点登录》。 2、客户端应用 从客户端应用开始。当然，使用 Spring Boot 构建。 2.1、Maven 依赖 在 pom.xml 中加入以下依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.security.oauth.boot</groupId> <artifactId>spring-security-oauth2-autoconfigure</artifactId> <version>2.0.1.RELEASE</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> <dependency> <groupId>org.thymeleaf.extras</groupId> <artifactId>thymeleaf-extras-springsecurity4</artifactId> </dependency> 2.2、Security 配置 接下来是最重要的部分，即客户端应用的 Security 配置： https://springdoc.cn/java-undeclaredthrowableexception/ Sun, 17 Dec 2023 11:16:48 +0800 https://springdoc.cn/java-undeclaredthrowableexception/ 1、概览 本文将带你了解 Java 抛出 UndeclaredThrowableException 异常的原因。 2、UndeclaredThrowableException 从理论上讲，当我们尝试抛出一个未声明的受检异常时，Java 会抛出一个 UndeclaredThrowableException 异常。也就是说，我们没有在 throws 子句中声明受检异常，但却在方法体中抛出了该异常。 受检异常 - 指的是必须要调用者用 try/catch 语句处理或者是再次 throws 出去的异常（即非 RuntimeException 子类）。 有人可能会说这是不可能的，因为 Java 编译器会通过编译错误来防止这种情况发生。 例如，如果我们尝试编译： public void undeclared() { throw new IOException(); } Java 编译器提示的失败信息如下： java: unreported exception java.io.IOException; must be caught or declared to be thrown 尽管在编译时可能不会抛出未声明的受检异常，但在运行时仍有可能发生。 例如，一个运行时代理拦截一个不抛出任何异常的方法： public void save(Object data) { // 省略 } 如果代理本身抛出了受检异常，从调用者的角度来看，save 方法也会抛出受检异常。调用者可能对该代理一无所知，因此会将该异常归咎于 save 方法。 在这种情况下，Java 会将实际已检查异常封装在 UndeclaredThrowableException 中，然后抛出 UndeclaredThrowableException。而 UndeclaredThrowableException 本身就是一个 非受检异常（RuntimeException）。 https://springdoc.cn/spring-boot-yaml-list/ Sun, 17 Dec 2023 10:38:41 +0800 https://springdoc.cn/spring-boot-yaml-list/ 1、概览 本文将带你了解如何在 YAML 中定义列表，以及如何在 Spring Boot 中把 YAML 列表映射为 Java List 对象。 2、回顾一下 YAML 中的列表 简而言之，YAML 是一种人类可读的数据序列化标准，为编写配置文件提供了一种简洁明了的方法。YAML 的优点在于它支持多种数据类型，如 List、Map 和标量（Scalar）类型。 YAML 列表中的元素使用 - 字符定义，它们的缩进级别相同： yamlconfig: list: - item1 - item2 - item3 - item4 相比之下，在 properties 中定义列表则使用的是索引值： yamlconfig.list[0]=item1 yamlconfig.list[1]=item2 yamlconfig.list[2]=item3 yamlconfig.list[3]=item4 与 properties 文件相比，YAML 的分层性质大大提高了可读性。YAML 的另一个功能是可以为不同的 Spring Profile 定义不同的属性。从 Boot 2.4.0 版开始，properties 文件也可以这样做。 Spring Boot 为 YAML 配置提供了开箱即用的支持。根据设计，Spring Boot 会在启动时从 application.yml 中加载配置属性，无需任何额外工作。 3、将 YAML 列表绑定至简单的 List Spring Boot 提供了 @ConfigurationProperties 注解，以简化将外部配置数据映射到对象模型的逻辑。 https://springdoc.cn/spring-boot-websocket-logging-online/ Sat, 16 Dec 2023 15:01:25 +0800 https://springdoc.cn/spring-boot-websocket-logging-online/ 本文将带你了解如何在 Spring Boot 应用中使用 WebSocket 构建一个在线的日志系统。通过该系统，不需要登录服务器，即可在 HTML 页面上通过 WebSocket 长连接预览到服务器的即时日志。 创建 Spring Boot 应用 添加 spring-boot-starter-websocket 依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> WebSocket 配置 创建 WebSocketConfiguration 配置类，配置 ServerEndpointExporter Bean，用于扫描系统中的 WebSocket 端点实现。 package cn.springdoc.demo.configuration; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.socket.server.standard.ServerEndpointExporter; @Configuration public class WebSocketConfiguration { @Bean public ServerEndpointExporter serverEndpointExporter() { return new ServerEndpointExporter(); } } 创建日志端点 创建 LoggingChannel WebSocket 端点实现类，接受客户端连接，并且推送日志消息。 package cn.springdoc.demo.web.channel; import java. https://springdoc.cn/spring-security-vs-apache-shiro/ Sat, 16 Dec 2023 12:13:59 +0800 https://springdoc.cn/spring-security-vs-apache-shiro/ 1、概览 在应用开发中，尤其是在企业级 Web 和移动应用领域，安全是一个首要问题。 本文将带你了解、比较两种流行的 Java 安全框架 - Apache Shiro 和 Spring Security。 2、背景 Apache Shiro 诞生于 2004 年，原名 JSecurity，2008 年被 Apache 基金会接受。迄今为止，它已发布了多个版本，最新版本为 1.13.0。 Spring Security 起源于 2003 年的 Acegi，在 2008 年首次公开发布时被纳入 Spring 框架。自诞生以来，它经历了多次迭代，目前的 GA 版本是 6.2.0。 这两种技术都提供身份认证和授权支持，以及加密和 Session 管理解决方案。此外，Spring Security 还提供了一流的保护，防范诸如 CSRF 和会话固定等攻击。 接下来，我们将通过使用 FreeMarker 的 Spring Boot 应用来演示如何使用这两种技术进行身份认证和授权。 3、配置 Apache Shiro 首先，来看看这两种框架的配置有何不同。 3.1、Maven 依赖 添加 shiro-spring-boot-web-starter 和 shiro-core 依赖： <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring-boot-web-starter</artifactId> <version>1.5.3</version> </dependency> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId> <version>1.5.3</version> </dependency> 依赖的最新版本可在 Maven Central 上找到。 https://springdoc.cn/spring-application-context/ Sat, 16 Dec 2023 11:11:21 +0800 https://springdoc.cn/spring-application-context/ 1、概览 本文将带你详细了解 Spring 中的 ApplicationContext 接口。 2、ApplicationContext 接口 Spring 框架的主要功能之一是 IoC（控制反转）容器。Spring IoC 容器负责管理应用的对象。它使用依赖注入来实现控制反转。 BeanFactory 和 ApplicationContext 接口，代表 Spring IoC 容器。其中，BeanFactory 是访问 Spring 容器的根接口。它提供了管理 Bean 的基本功能。 而 ApplicationContext 是 BeanFactory 的子接口。因此，它具备 BeanFactory 的所有功能。 此外，它还提供了更多面向企业的特定功能。ApplicationContext 的重要功能包括解析消息、支持国际化、发布事件以及应用层特定的上下文。这就是为什么我们将其作为默认的 Spring 容器使用的原因。 3、Spring Bean 是什么？ 在深入了解 ApplicationContext 容器之前，有必要了解一下 Spring Bean。在 Spring 中，Bean 是 Spring 容器实例化、组装和管理的对象。 那么，是否应该将应用的所有对象都配置为 Spring Bean 呢？作为最佳实践，不应该这样做。 一般来说，根据 Spring 文档 所述，应该为服务层对象、数据访问对象 (DAO)、表现对象、基础架构对象（如 Hibernate SessionFactory、JMS Queue 等）定义 Bean。 此外，通常情况下，不应该在容器中配置细粒度的 Domain 对象。创建和加载 Domain 对象通常是 DAO 和业务逻辑的职责。 https://springdoc.cn/spring-boot-docker-images/ Sat, 16 Dec 2023 10:26:00 +0800 https://springdoc.cn/spring-boot-docker-images/ 1、概览 随着越来越多的企业转向使用容器，Docker 在软件开发中的地位也越来越重要。为此，Spring Boot 2.3 的一大新功能就是为 Spring Boot 应用轻松创建 Docker 镜像提供了支持。 本文将带你了解如何为 Spring Boot 应用创建 Docker 镜像。 2、传统的 Docker 构建 使用 Spring Boot 构建 Docker 镜像的传统方法是使用 Dockerfile。 下面是一个简单的 Dockerfile 示例： FROM openjdk:8-jdk-alpine EXPOSE 8080 ARG JAR_FILE=target/demo-app-1.0.0.jar ADD ${JAR_FILE} app.jar ENTRYPOINT ["java","-jar","/app.jar"] 然后，使用 docker build 命令创建 Docker 镜像。这对大多数应用都很有效，但也有一些缺点。 首先，我们使用的是 Spring Boot 创建的 Fat jar。这会影响启动时间，尤其是在容器化环境中。我们可以通过添加 Jar 文件的解压内容来节省启动时间。 其次，Docker 镜像是分层构建的。Spring Boot Fat Jar 的性质导致所有应用代码和第三方库都被放在一个层中。这意味着，即使只有一行代码发生变化，也必须重建整个层。 通过在构建之前解压 Jar 文件，应用代码和第三方库分别有自己的层。这使我们能够利用 Docker 的缓存机制，当更改一行代码时，只需要重新构建相应的层。 有了这个理念，让我们看看 Spring Boot 如何改进创建 Docker 镜像的过程。 https://springdoc.cn/cron-syntax-linux-vs-spring/ Sat, 16 Dec 2023 10:11:22 +0800 https://springdoc.cn/cron-syntax-linux-vs-spring/ 1、概览 通过 Cron 表达式，我们可以安排任务在特定日期和时间定期运行。Cron 表达式在 Unix 中推出后，其他基于 Unix 的操作系统和软件库（包括 Spring）都采用了它的任务调度方法。 本文将带你了解基于 Unix 操作系统的 Cron 表达式与 Spring Cron 之间的区别。 2、Unix Cron 在大多数基于 Unix 的系统中，Cron 有五个字段：分钟（0-59）、小时（0-23）、月日（1-31）、月份（1-12 或名称）和星期（0-7 或名称）。 可以在每个字段中添加一些特殊值，如星号（*）： 5 0 * * * 任务将在每天午夜后 5 分钟执行。也可以使用数值范围： 5 0-5 * * * 如上，调度器将在午夜 12 点后 5 分钟执行任务，并在每天 1 点、2 点、3 点、4 点和 5 点后 5 分钟执行任务。 或者，可以使用一个值列表： 5 0,3 * * * 现在，调度器会在每天午夜 12 点后 5 分钟和下午 3 点后 5 分钟执行作业。原始 Cron 表达式提供的功能远不止这些。 https://springdoc.cn/spring-boot-xml-beans/ Sat, 16 Dec 2023 09:53:41 +0800 https://springdoc.cn/spring-boot-xml-beans/ 1、概览 在 Spring 3.0 之前，XML 是定义和配置 Bean 的唯一方法。Spring 3.0 引入了 JavaConfig，允许我们使用 Java 类配置 Bean。不过，如今有些项目仍然在使用 XML 配置文件。 本文将带你了解如何在 Spring Boot 应用中整合 XML 配置。 2、@ImportResource 注解 @ImportResource 注解可以导入一个或多个包含 Bean 定义的资源。 比方说，我们有一个包含 Bean 定义的 beans.xml 文件： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <bean class="com.baeldung.springbootxml.Pojo"> <property name="field" value="sample-value"></property> </bean> </beans> 要在 Spring Boot 应用中使用它，可以使用 @ImportResource 注解，告诉它在哪里可以找到配置文件： @Configuration @ImportResource("classpath:beans.xml") public class SpringBootXmlApplication implements CommandLineRunner { @Autowired private Pojo pojo; public static void main(String[] args) { SpringApplication. https://springdoc.cn/spring-boot-flyway-repair/ Fri, 15 Dec 2023 15:58:24 +0800 https://springdoc.cn/spring-boot-flyway-repair/ 1、概览 Flyway 迁移并不总是一帆风顺行，本文将带你了解迁移失败后的恢复方案。 2、设置 从基本的 Spring Boot 配置 Flyway 开始。它依赖 flyway-core、spring-boot-starter-jdbc 和 flyway-maven-plugin。 对于如何在 Spring Boot 中使用 Flyway 进行数据库迁移，你可以参阅 这篇文章。 2.1、配置 首先，添加两个不同的 Profile（配置文件）。这能够轻松地针对不同的数据库引擎运行迁移： <profile> <id>h2</id> <activation> <activeByDefault>true</activeByDefault> </activation> <dependencies> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> </dependency> </dependencies> </profile> <profile> <id>postgre</id> <dependencies> <dependency> <groupId>org.postgresql</groupId> <artifactId>postgresql</artifactId> </dependency> </dependencies> </profile> 还要为每个 Profile 添加 Flyway 数据库配置文件。 首先，创建 application-h2.properties： flyway.url=jdbc:h2:file:./testdb;DB_CLOSE_ON_EXIT=FALSE;AUTO_RECONNECT=TRUE;MODE=MySQL;DATABASE_TO_UPPER=false; flyway.user=testuser flyway.password=password 然后，创建 PostgreSQL application-postgre.properties： flyway.url=jdbc:postgresql://127.0.0.1:5431/testdb flyway.user=testuser flyway.password=password 注：你可以调整 PostgreSQL 配置，使其与你的数据库相匹配，也可以使用 代码示例中的 docker-compose 文件。 2.2、迁移 添加第一个迁移（migration）文件 V1_0__add_table.sql： create table table_one ( id numeric primary key ); 添加第二个包含错误的迁移文件 V1_1__add_table. https://springdoc.cn/spring-mvc-pathvariable-dot/ Fri, 15 Dec 2023 15:21:15 +0800 https://springdoc.cn/spring-mvc-pathvariable-dot/ 1、概览 使用 Spring 的 @PathVariable 和 @RequestMapping 来映射包含点的请求时，最后一个 URI 路径变量的值被会截断。 2、原因 具体来说，Spring 认为最后一个点后面的任何内容都是文件扩展名，如 .json 或 .xml，因此，它会截断值以检索路径变量。 来看一个使用路径变量的例子： @RestController public class CustomController { @GetMapping("/example/{firstValue}/{secondValue}") public void example(@PathVariable("firstValue") String firstValue, @PathVariable("secondValue") String secondValue) { // ... } } 如上，考虑以下请求 URL 以及 firstValue 和 secondValue 变量的值： example/gallery/link：firstValue = "gallery"，secondValue = "link"。 example/gallery.df/link.ar URL：firstValue = "gallery.df "，secondValue = "link" example/gallery.df/link.com.ar：firstValue = "gallery.df"，secondValue = "link.com" 可以看到，第一个变量不受影响，但第二个带点（.）的变量总是被截断。 3、解决办法 解决这种不便的方法之一是修改 @PathVariable 定义，添加一个 regex（正则）映射。这样，任何点（包括最后一个点）都将被视为参数的一部分： @GetMapping("/example/{firstValue}/{secondValue:.+}") public void example( @PathVariable("firstValue") String firstValue, @PathVariable("secondValue") String secondValue) { //. https://springdoc.cn/spring-pathvariable/ Fri, 15 Dec 2023 14:53:31 +0800 https://springdoc.cn/spring-pathvariable/ 1、概览 本文将带你了解 Spring 中 @PathVariable 注解的作用和用法。 简单地说，@PathVariable 注解可用于处理请求 URI 映射中的模板变量，并将其绑定到 Controller 方法参数。 2、示例映射 @PathVariable 注解的一个简单用例是用于标识具有 ID 的实体的端点： @GetMapping("/api/employees/{id}") @ResponseBody public String getEmployeesById(@PathVariable String id) { return "ID: " + id; } 在本例中，使用 @PathVariable 注解来提取 URI 的模板部分，该部分由变量 {id} 表示。 调用示例如下： http://localhost:8080/api/employees/111 ---- ID: 111 3、指定 PATH （路径）变量名 在上一个示例中，由于方法参数和路径变量的名称相同，可以不用主动设置模板路径变量的名称。 如果路径变量名不同，可以在 @PathVariable 注解的参数中指定： @GetMapping("/api/employeeswithvariable/{id}") @ResponseBody public String getEmployeesByIdWithVariableName(@PathVariable("id") String employeeId) { return "ID: " + employeeId; } 测试如下： http://localhost:8080/api/employeeswithvariable/1 ---- ID: 1 为了清晰起见，还可以将路径变量名定义为 @PathVariable(value="id")，而不是 PathVariable("id")。 https://springdoc.cn/spring-security-oauth-resource-server/ Fri, 15 Dec 2023 13:45:36 +0800 https://springdoc.cn/spring-security-oauth-resource-server/ 1、概览 本文将带你了解如何使用 Spring Security 构建 OAuth 2.0 资源服务器（使用 JWT 和 Opaque Token，这两种由 Spring Security 支持的 Bearer Token）。 2、背景介绍 2.1、JWT 和 Opaque Token 是什么？ JWT 或 JSON Web Token 是一种以广泛接受的 JSON 格式安全传输敏感信息的方式。其中包含的信息可能是关于用户的，也可能是关于 Token 本身的，例如其 expiry（有效期）和 issuer（签发者）。 Opaque Token 顾名思义，它所携带的信息是不透明的。Token 只是一个标识符，指向存储在授权服务器上的信息；它通过服务器端的自省（Introspection）进行验证。 2.2、资源服务器是什么？ 在 OAuth 2.0 中，资源服务器是通过 OAuth Token 保护资源的应用。这些 Token 由授权服务器（通常是客户端应用）签发。资源服务器的工作是在向客户端提供资源之前验证 Token。 令牌的有效性由几个因素决定： 该令牌是否来自配置的授权服务器？ 是否未过期？ 该资源是否为预期受众（audience）提供服务？ Token 是否具有访问所请求资源的必要权限？ 来看一下 授权码模式 的顺序图，并观察所有相关的参与者： 正如在步骤 8 中看到的，当客户端应用调用资源服务器的 API 访问受保护的资源时，它首先会转到授权服务器，以验证请求的 Authorization: Bearer Header 信息中包含的 Token，然后响应客户端。 本文的重点是第 9 步。 https://springdoc.cn/spring-webflux-concurrency/ Fri, 15 Dec 2023 10:26:00 +0800 https://springdoc.cn/spring-webflux-concurrency/ 1、简介 本文将带你了解 Spring WebFlux 响应式应用中的并发。 2、响应式编程的动机 一个典型的 Web 应用由多个复杂的交互部分组成。其中许多交互在本质上是阻塞性的，例如那些涉及数据库调用以获取或更新数据的交互。而其他几个部分则是独立的，可以 并发 执行，也可能是 并行 执行。 并发是多个任务在同一时间段内交替执行，而并行是多个任务同时执行。并发关注的是任务的调度和切换，以提高系统的效率和响应性，而并行关注的是任务的同时执行，以提高计算速度和性能。 例如，用户对 Web 服务器的两个请求可以由不同的线程处理。在多核平台上，这对整体响应时间有明显的好处。因此，这种并发模型被称 thread-per-request（每个请求一个线程）模型： 如上图，每个线程一次处理一个请求。 虽然基于线程的并发为我们解决了部分问题，但却无法解决单个线程内的大部分交互仍然是阻塞的这一事实。此外，在 Java 中使用原生线程来实现并发时，还需要付出上下文切换的巨大代价。 与此同时，随着 Web 应用面临的请求越来越多，thread-per-request 模式开始无法满足人们的期望。 因此，我们需要一种并发模型，它可以帮助我们用相对较少的线程数处理越来越多的请求。这也是采用响应式编程的主要动机之一。 3、响应式编程中的并发 响应式编程可以帮助我们根据数据流和变化的传播来构建程序。在完全无阻塞的环境中，这可以让我们实现更高的并发性和更好的资源利用率。 然而，响应式编程是否完全摒弃了基于线程的并发？虽然这种说法有些激烈，但响应式编程肯定与使用线程实现并发的方法截然不同。响应式编程带来的根本区别在于 异步。 换句话说，程序流程从一连串同步操作转变为异步事件流。 例如，在响应式模型下，对数据库的读取调用不会在获取数据时阻塞调用线程。调用会立即返回一个发布者（Publisher），其他人可以订阅该发布者。订阅者（Subscriber）可以在事件发生后对其进行处理，甚至可以自己进一步生成事件： 最重要的是，响应式编程并不强调应该生成和消耗哪个线程事件。相反，它强调的是将程序构造成异步事件流。 这里的发布者和订阅者不需要属于同一个线程。这有助于我们更好地利用可用线程，从而提高整体并发性。 4、Event Loop Event Loop（事件循环）模型是一种用于服务器的响应式异步编程模型： 上图是一个事件循环的抽象设计，展示了响应式异步编程的思想： Event Loop 在单个线程中连续运行，我们可以根据可用内核的数量设置多个 Event Loop。 Event Loop 按顺序处理来自事件队列的事件，并在向平台注册回调后立即返回。 Platform（平台）可以触发操作的完成，如数据库调用或外部服务调用。 Event Loop 可在 operation（操作）完成通知时触发 callback（回调），并将结果发回给原始调用者。 包括 Node.js、Netty 和 Ngnix 在内的许多平台都实现了 Event Loop 模型。与 Apache HTTP 服务器、Tomcat 或 JBoss 等传统平台相比，它们具有更好的可扩展性。 5、用 Spring WebFlux 进行响应式编程 对响应式编程及其并发模型有了足够的了解后，来看看 Spring WebFlux。它是 Spring 在 5. https://springdoc.cn/yaml-map-pojo/ Thu, 14 Dec 2023 13:16:55 +0800 https://springdoc.cn/yaml-map-pojo/ 1、概览 本文将带你了解如何在 YAML 配置文件中定义 POJO 类中的 Map 属性。 2、POJO 和 YAML POJO 即 Plain Old Java Objects（普通旧 Java 对象）。YAML 是一种人类可读的结构化数据格式，使用缩进表示嵌套。 2.1、简单的 Map 假设我们正在经营一家网店，并且要创建一个服装尺码转换的服务。起初，我们只销售英国的服装。我们想知道标签 S、M、L 等代表的是英国的哪个尺码。 创建 POJO 配置类： @ConfigurationProperties(prefix = "t-shirt-size") public class TshirtSizeConfig { private Map<String, Integer> simpleMapping; public TshirtSizeConfig(Map<String, Integer> simpleMapping) { this.simpleMapping = simpleMapping; } //get、set } 注意 @ConfigurationProperties 注解的 prefix 值表示配置前缀，在下一章会定义该配置。 还要在 Application.class 上使用以下注解启用配置属性类： @EnableConfigurationProperties(TshirtSizeConfig.class) public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } } 2. https://springdoc.cn/spring-boot-health-indicators/ Thu, 14 Dec 2023 12:19:40 +0800 https://springdoc.cn/spring-boot-health-indicators/ 1、概览 Spring Boot 提供了几种不同的方法来检查运行中的应用及其组件的状态和健康状况。在这些方法中，HealthContributor 和 HealthIndicator API 是值得注意的两种。 本文将带你了解这些 API 的原理以及如何向它们提供自定义信息。 2、依赖 Health Information Contributor（健康信息贡献者）是 Spring Boot Actuator 模块的一部分： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> 3、内置的 HealthIndicator Spring Boot 注册了许多开箱即用的 HealthIndicator 来报告应用特定方面的健康状况。 其中一些指标默认已经注册了，如 DiskSpaceHealthIndicator 或 PingHealthIndicator。前者报告磁盘的当前状态，后者则作为应用的 ping 端点。 Spring Boot 也会有条件地注册一些指标。也就是说，如果 classpath 上存在某些依赖或满足某些其他条件，Spring Boot 可能也会注册一些其他的 HealthIndicator。例如，如果使用了关系型数据库，那么 Spring Boot 就会注册 DataSourceHealthIndicator。同样，如果使用的是 Cassandra 作为数据存储，它会注册 CassandraHealthIndicator。 可以调用 /actuator/health 端点来检查 Spring Boot 应用的健康状态。该端点会报告所有已注册的 HealthIndicator 的汇总结果。 如果要查看某个特定指标的健康报告，可以调用 /actuator/health/{name} 端点。例如，调用 /actuator/health/diskSpace 端点将返回 DiskSpaceHealthIndicator 的状态报告： { "status": "UP", "details": { "total": 499963170816, "free": 134414831616, "threshold": 10485760, "exists": true } } 4、自定义 HealthIndicator 除了内置的 HealthIndicator，还可以注册自定义 HealthIndicator 来报告组件或子系统的健康状况。只需将 HealthIndicator 接口的实现注册为 Spring Bean 即可。 https://springdoc.cn/spring-boot-yaml-vs-properties/ Thu, 14 Dec 2023 10:28:24 +0800 https://springdoc.cn/spring-boot-yaml-vs-properties/ 1、概览 Spring Boot 中的一个常见做法是使用外部配置来定义属性。这样，就可以在不同的环境中使用相同的应用程序代码。 外部配置可以使用 properties 文件、YAML 文件、环境变量和命令行参数。 本文将带你了解 properties 文件和 YAML 文件的主要区别。 2、Properties 配置 默认情况下，Spring Boot 可以访问在 application.properties 文件中设置的配置，该文件使用键值格式： spring.datasource.url=jdbc:h2:dev spring.datasource.username=SA spring.datasource.password=password 如上，每一行都是一个单独的配置，因此需要为 key 使用相同的前缀来表达分层数据。在本例中，每个 key 都属于 spring.datasource。 2.1、Properties 中的占位符 在值中，可以使用 ${} 语法的占位符来引用其他 key、系统属性或环境变量的内容： app.name=MyApp app.description=${app.name} is a Spring Boot application 2.2、列表 如果同类 properties 具有不同的值，可以用数组索引来表示列表结构： application.servers[0].ip=127.0.0.1 application.servers[0].path=/path1 application.servers[1].ip=127.0.0.2 application.servers[1].path=/path2 application.servers[2].ip=127.0.0.3 application.servers[2].path=/path3 2.3、多文档 自 2.4.0 版起，Spring Boot 支持创建多文档 properties 文件。简单地说，可以将单个物理文件拆分成多个逻辑文档。 这样，就可以在同一个 properties 文件中声明多个 Profile： logging.file.name=myapplication.log bael.property=defaultValue #--- spring.config.activate.on-profile=dev spring.datasource.password=password spring.datasource.url=jdbc:h2:dev spring. https://springdoc.cn/spring-boot-web-server-shutdown/ Wed, 13 Dec 2023 14:02:10 +0800 https://springdoc.cn/spring-boot-web-server-shutdown/ 本文将带你了解如何在 Spring Boot 应用中配置优雅停机。 1、优雅停机 从 Spring Boot 2.3 开始，Spring Boot 所支持的四种嵌入式 Web 服务器（Tomcat、Jetty、Undertow 和 Netty）都支持在 Servlet 和响应式平台上的优雅关机功能。 只需在 application.properties 文件中将 server.shutdown 属性设置为 graceful，即可启用优雅停机： server.shutdown=graceful 在优雅停机阶段，Tomcat、Netty 和 Jetty 会停止接受新的 Web 请求。而 Undertow 会继续接受，但会立即向客户端发送 503 Service Unavailable 响应。 默认情况下，该属性的值等于 immediate，这意味着服务器会立即关闭。 在优雅关机时，可能有一些之前的请求仍在处理中。在这种情况下，服务器会等待这些活动请求在指定时间内完成。 可以使用 spring.lifecycle.timeout-per-shutdown-phase 配置属性来配置超时时间： spring.lifecycle.timeout-per-shutdown-phase=1m 如上，在优雅停机时，对于那些仍在处理的请求，服务器等待最多一分钟。该属性的默认值为 30 秒。 2、总结 本文介绍了如何在 Spring Boot 中配置优雅停机，以及如何配置服务器停机超时时间。 Ref：https://www.baeldung.com/spring-boot-web-server-shutdown https://springdoc.cn/spring-mvc-async-vs-webflux/ Wed, 13 Dec 2023 12:20:05 +0800 https://springdoc.cn/spring-mvc-async-vs-webflux/ 1、概览 本文将带你了解 Spring Async 和 Spring WebFlux 之间的区别。 2、场景 本文分别用 Spring Async 和 Spring WebFlux 来实现一个简单的 Web 应用。 Web 请求会通过一个延迟时间为 200 毫秒的 Filter，然后 Controller 需要 500 毫秒来计算并返回结果。 最后使用 Apache ab 分别进行负载测试，并使用 JConsole 监控应用的行为。 3、Spring MVC Async Spring 3.0 引入了 @Async 注解。@Async 的目标是允许应用在单独的线程上运行重负载的任务。此外，调用方可以等待结果（如果感兴趣）。因此，返回类型不能是void，而可以是 Future、CompletableFuture 或 ListenableFuture 之一。 Spring 3.2 引入了 org.springframework.web.context.request.async 包，它与 Servlet 3.0 一起为 Web 层带来了异步的支持。因此，自 Spring 3.2 起，@Async 可以在 @Controller 或 @RestController 类中使用。 当客户端发起请求时，请求会经过过滤器链（filter chain）中所有匹配的过滤器（filter），直到到达 DispatcherServlet 实例。 然后，Servlet 会对请求进行异步调度。它通过调用 AsyncWebRequest#startAsync 将请求标记为已启动，将请求处理转移到 WebSyncManager 的实例，然后在不提交响应的情况下完成其工作。过滤器链也按相反的方向遍历执行到根节点。 https://springdoc.cn/swagger-ui-turn-off-in-production/ Wed, 13 Dec 2023 11:59:21 +0800 https://springdoc.cn/swagger-ui-turn-off-in-production/ 1、概览 在开发环境下使用 Swagger UI 可以很方便地查看、测试 REST 服务。但是出于安全考虑，在生产环境中往往需要禁用 Swagger UI。 2、Swagger 配置 要 使用 SpringDoc 设置 Swagger，需要在配置 Bean 中对其进行定义。 创建 SwaggerConfig 类： @Configuration public class SwaggerConfig { @Bean public OpenAPI openAPI() { return new OpenAPI().info(new Info().title("SpringDoc Disable SwaggerUI example") .description("SpringDoc Disable SwaggerUI application") .version("v0.0.1")); } } 默认情况下，该配置 Bean 会添加到 Spring Context 中。这样，Swagger 可以在所有环境中使用。 3、使用 Spring Profile 在 Spring 中，可以使用 @Profile 注解来启用或禁用 Bean。 使用 SpEL 表达式来指定在哪些环境中激活 Swagger。 @Profile({"!prod && swagger"}) 如上，在 swagger Profile，且不是 prod Profile 的情况下才会启注解的 Bean。 https://springdoc.cn/keycloak-custom-login-page/ Wed, 13 Dec 2023 10:50:12 +0800 https://springdoc.cn/keycloak-custom-login-page/ 1、概览 Keycloak 是第三方授权服务器，用于管理 Web 或移动应用的身份验证和授权。它为用户提供了一个默认的登录页面。 本文将带你了解如何自定义 Keycloak 服务器的登录页面。 本文在 《自定义 Keycloak 主题》 基础上进行实现。 2、独立 Keycloak 服务器 继续以 custom 主题为例，先看看独立服务器。 2.1、管理控制台设置 进入 Keycloak 目录，然后在 bin 文件夹中运行如下命令，启动服务器： kc.[sh|bat] start-dev --spi-theme-static-max-age=-1 --spi-theme-cache-themes=false --spi-theme-cache-templates=false 使用上述命令启动服务器后，只需刷新页面，就能看到更改。 现在，在 themes/custom 目录中新建一个名为 login 的文件夹。为了简单起见，先将 themes/keycloak/login 目录中的所有内容复制到这里。这是默认的登录页面主题。 然后，进入管理控制台（http://localhost:8080/admin/master/console），使用 initial1/zaq1!QAZ 凭证登录，并进入 Realm 的 “Themes” 选项卡： 为 Login Theme 选择 custom，然后保存更改。 现在就可以尝试一些自定义功能了。不过在此之前，先来看看默认登录页面： 2.2、添加自定义内容 现在，假设我们需要更改背景。 打开 login/resources/css/login.css 并更改 class 定义： .login-pf body { background: #39a5dc; background-size: cover; height: 100%; } 刷新页面即可看到效果： 接下来，尝试更改用户名和密码的标签。 https://springdoc.cn/spring-keycloak-custom-themes/ Wed, 13 Dec 2023 09:53:37 +0800 https://springdoc.cn/spring-keycloak-custom-themes/ 1、概览 Keycloak 是一个开源的身份和访问管理（Identity and Access Management，IAM）解决方案，可以作为第三方授权服务器来管理 Web 或移动应用的身份验证和授权。 本文将带你了解如何自定义 Keycloak 的主题，为终端用户的网页提供不同的外观。 本文以之前的文章为基础：《Keycloak 指南》和《在 Spring Boot 中嵌入 Keycloak》。因此，对于初学者来说，最好先阅读这两篇文章。 2、Keycloak 的主题 2.1、默认主题 Keycloak 中预置了几个主题，并与发行版绑定在一起。 对于单机版服务器，可在 ../lib/lib/main/org.keycloak.keycloak-themes-20.0.3.jar（可使用任何标准 ZIP 压缩工具打开）的主题目录下的不同文件夹中找到这些主题： base：包含 HTML 模板和 Message Bundle 的骨架主题；所有主题（包括自定义主题）一般都继承自 base 主题 keycloak：包含用于美化页面的图片和样式表；如果我们不提供自定义主题，则默认使用该主题 keycloak.v2：基于 React 的主题；新管理控制台的一部分；旧控制台已过时，将在 Keycloak 21 中移除。 不建议修改现有主题。相反，应该创建一个新主题，从上述两个主题中继承。 要创建一个新的自定义主题，需要在 themes 目录中添加一个新的文件夹，称之为 custom。如果想要完全重建，则建议从 base 文件夹中复制内容。 在本例中，我们并不打算替换所有内容，因此从 keycloak 目录中获取内容。 2.2、主题类型 Keycloak 支持五种主题： Welcome：用于欢迎页 Login：用于登录、OTP、授予、注册和忘记密码页面 Account：用于用户账户管理页面 Admin Console：用于管理控制台 Email：用于服务器发送的电子邮件 上述列表中的最后四个主题可以通过独立服务器的管理控制台进行设置。当我们在 themes 目录下创建一个新文件夹后，服务器重启后就可以选择该文件夹。 使用凭证 initial1 / zaq1!QAZ（在 上一文章 中设置的）登录管理控制台，并转到 Realm 的 “Themes” 选项卡： https://springdoc.cn/spring-boot-arthas-get-prpperty-source/ Tue, 12 Dec 2023 18:01:14 +0800 https://springdoc.cn/spring-boot-arthas-get-prpperty-source/ 背景 众所周之，Spring / Spring Boot 应用的配置注入方式非常多： System Properties / System Env application.properties / application.yaml Spring Profile Spring Cloud Config 还有很多配置注入的方式你可以参阅 中文文档，可谓是令人眼花缭乱。 获取运行时具体配置 对于开发人员来说，在运行时怎样确定某个配置是否生效？它的具体值是什么？ 通过 Arthas，只要一行命令就可以获取到。 例如，获取 server.port 的具体值： vmtool --action getInstances --className org.springframework.context.ConfigurableApplicationContext --express 'instances[0].getEnvironment().getProperty("server.port")'@String[7001] 获取具体的配置来源 但是这个配置是从哪里来的？ 对于 spring boot 应用，可以打开一个新的 terminal 窗口，执行 telnet 127.0.0.1 3658 连接上Arthas。 直接 watch 下面的函数。 在原来窗口用上面的 vmtool 命令来获取 server.port 的值。 从 watch 返回结果中可以看到，server.port 值来源于 application.yml： watch org.springframework.boot.context.properties.source.ConfigurationPropertySourcesPropertySource findConfigurationPropertyPress Q or Ctrl+C to abort.Affect(class count: 1 , method count: 2) cost in 217 ms, listenerId: 5method=org. https://springdoc.cn/keycloak-embedded-in-spring-boot-app/ Tue, 12 Dec 2023 16:45:26 +0800 https://springdoc.cn/keycloak-embedded-in-spring-boot-app/ 1、概览 Keycloak 是由 Red Hat 管理和在 Java 中由 JBoss 开发的开源身份和访问管理解决方案。 本文将带你了解如何在 在 Spring Boot 中嵌入 Keycloak 服务器，这样就能轻松启动预配置的 Keycloak 服务器。 Keycloak 也可以作为 独立服务器 运行，但需要下载并通过管理控制台进行设置。 2、Keycloak 预配置 服务器包含一组 Realm，每个 Realm 都是用户管理的独立单元。要对其进行预配置，我们需要指定一个 JSON 格式的 Realm 定义文件。 使用 Keycloak Admin 控制台 配置的所有内容都以 JSON 格式进行持久化。 我们的授权服务器将使用名为 baeldung-realm.json 的 JSON 文件进行预配置。文件中的几个相关配置如下： users：默认用户是 john@test.com 和 mike@other.com；对应的凭证也在这里。 clients：定义一个 ID 为 newClient 的客户端 standardFlowEnabled：设置为 true，激活 newClient 的授权码（Authorization Code）授权模式。 redirectUris：newClient 在成功验证后将重定向到的服务器 URL webOrigins：置为 +，为所有 redirectUris 的 URL 提供 CORS 支持 Keycloak 服务器会默认签发 JWT Token，因此无需为此进行单独配置。接下来看看 Maven 的配置。 https://springdoc.cn/spring-conditionalonproperty/ Tue, 12 Dec 2023 16:09:06 +0800 https://springdoc.cn/spring-conditionalonproperty/ 1、概览 本文将带你了解 Spring 中 @ConditionalOnProperty 注解的作用和用法。 2、@ConditionalOnProperty 的作用 通常，在开发基于 Spring 的应用时，需要根据配置属性是否存在，或者配置属性有指定的值来有条件地创建一些 Bean。 例如，我们需要注册一个 DataSource Bean，并且要根据属性值设置为 prod 还是 test 来创建生产数据库或测试数据库。 这正是 @ConditionalOnProperty 注解的用武之地。 简而言之，@ConditionalOnProperty 只有在环境属性存在且具有指定值的情况下才会启用 Bean 注册。默认情况下，指定的属性必须已定义且等于指定的值。 熟悉了 @ConditionalOnProperty 注解的用途后，接着来深入了解一下如何使用。 3、@ConditionalOnProperty 注解实践 开发一个基本的电子邮件通知系统来示范 @ConditionalOnProperty 的使用。 首先，创建一个简单的服务来发送通知消息。 定义 NotificationSender 接口： public interface NotificationSender { String send(String message); } 接下来，提供一个 NotificationSender 接口的实现来发送电子邮件： public class EmailNotification implements NotificationSender { @Override public String send(String message) { return "Email Notification: " + message; } } 现在，来看看如何使用 @ConditionalOnProperty 注解。 https://springdoc.cn/spring-dynamicpropertysource/ Tue, 12 Dec 2023 10:17:06 +0800 https://springdoc.cn/spring-dynamicpropertysource/ 1、概览 当代应用通常需要连接到各种外部服务，如 PostgreSQL、Apache Kafka、Cassandra、Redis 和其他外部 API。 本文将带你了解 Spring 如何通过引入动态属性（@DynamicPropertySource）来帮助测试此类应用。 2、问题：动态属性 假设我们正在开发一个使用 PostgreSQL 作为数据库的应用。 创建 JPA 实体： @Entity @Table(name = "articles") public class Article { @Id @GeneratedValue(strategy = IDENTITY) private Long id; private String title; private String content; // get、set 省略 } 我们需要编写测试来确保应用按预期运行，由于该测试需要与真实数据库创建连接，我们应该事先建立一个 PostgreSQL 实例。 在测试执行过程中，有不同的方法来设置此类基础工具。事实上，这类解决方案主要有三类： 专门为测试设置一个单独的数据库服务器 使用一些轻量级的、测试专用的替代品，如 H2 让测试本身管理数据库的生命周期 由于未区分测试环境和生产环境，与使用 H2 等测试替身相比，有更好的选择。第三个选项不仅可以与真实数据库一起使用，还可以为测试提供更好的隔离性。此外，借助 Docker 和 Testcontainers 等技术，实现第三个选项非常容易。 如果使用 Testcontainers 等技术，测试流程如下： 在所有测试前设置 PostgreSQL 等组件。通常，这些组件会监听随机端口。 运行测试。 卸载组件。 如果 PostgreSQL 容器每次都监听随机端口，那么我们就应该以某种方式动态设置和更改 spring.datasource.url 配置属性。基本上，每个测试都应该有自己的配置属性版本。 当配置是静态的时候，可以使用 Spring Boot 的配置管理工具轻松地对其进行管理。但是，当我们面对的是动态配置时，同样的任务就会变得比较麻烦。 https://springdoc.cn/spring-swagger-hiding-endpoints/ Tue, 12 Dec 2023 09:56:04 +0800 https://springdoc.cn/spring-swagger-hiding-endpoints/ 1、概览 在 Spring Boot 中使用 Swagger 文档时，有时候需要隐藏端点。最常见的情况就是，该端点还在开发中。或者是有一些内部端点，不想暴露给用户。 本文将带你了解如何在 Swagger API 文档中隐藏端点。 2、使用 @ApiIgnore 隐藏端点 可以在 Handler 方法上添加 @ApiIgnore 注解来隐藏端点： @ApiIgnore @ApiOperation(value = "This method is used to get the author name.") @GetMapping("/getAuthor") public String getAuthor() { return "Umang Budhwar"; } 3、使用 @ApiOperation 隐藏端点 也可以使用 @ApiOperation 来隐藏端点： @ApiOperation(value = "This method is used to get the current date.", hidden = true) @GetMapping("/getDate") public LocalDate getDate() { return LocalDate.now(); } 将 @ApiOperation 注解的 hidden 属性设置为 true，即可使 Swagger 忽略该端点。 https://springdoc.cn/spring-events-in-detail/ Mon, 11 Dec 2023 15:24:20 +0800 https://springdoc.cn/spring-events-in-detail/ 1、Spring 事件机制 有的人可能会觉得 Spring 中的事件机制很神奇，一个地方发消息，另一个地方收消息，跟 MQ 一样。其实，Spring 中的事件本质上就是观察者模式的应用。事件有其便利的一面，但是用多了也容易导致混乱，所以在实际项目中，我们还是要谨慎选择是否使用 Spring 事件。 2、简单实践 先用一个简单的案例，来让大家了解一下 Spring 中事件的应用。 事件发布流程中，有三个核心概念，它们之间的关系如下图： 事件源（ApplicationEvent）：这个就是你要发布的事件对象。 事件发布器（ApplicationEventPublisher）：这是事件的发布工具。 事件监听器（ApplicationListener）：这个相当于是事件的消费者。 以上三个要素，事件源和事件监听器都可以有多个，事件发布器（通常是由容器来扮演）一般来说只有一个。 接下来，让我们通过一个简单的案例来演示一下 Spring 中事件的用法。 首先，我们需要自定义一个事件对象，自定义的事件继承自 ApplicationEvent 类，如下： public class MyEvent extends ApplicationEvent { private String name; public MyEvent(Object source, String name) { super(source); this.name = name; } @Override public String toString() { return "MyEvent{" + "name='" + name + '\'' + "} " + super.toString(); } } 这里只额外定义了一个 name 属性，如果大家在事件发送的时候需要传递的数据比较多，那么就可以在这里定义更多的属性。 在具体实践中，事件源并非一定要继承自 ApplicationEvent，事件源也可以是一个普通的 Java 类，如果是普通的 Java 类，系统会自动将之封装为一个 PayloadApplicationEvent 对象去发送。 https://springdoc.cn/keycloak-custom-user-attributes/ Mon, 11 Dec 2023 11:21:01 +0800 https://springdoc.cn/keycloak-custom-user-attributes/ 1、概览 Keycloak 是第三方授权服务器，负责管理我们 Web 或移动应用的用户。 它提供了一些默认属性，例如名字、姓氏和电子邮件，用于存储任何给定用户的信息。但是很多时候，这些属性是不够的，我们可能需要添加一些特定于我们应用的额外用户属性。 本文将带你了解如何在 Keycloak 授权服务器中添加自定义用户属性，并在基于 Spring 的后端中访问它们。 2、独立服务器 2.1、添加自定义用户属性 基于上文 “Spring Boot 整合 Keycloak” 中的 Keycloak 服务器。 第一步是进入 Keycloak 的管理控制台。 在 Keycloak 发行版的 bin 文件夹中运行如下命令来启动服务器： kc.bat start-dev 然后，进入 Web 管理控制台 http://localhost:8180/auth/admin，输入凭证：initial1 / zaq1!QAZ 。 接下来，点击 “Manage” 选项卡下的 “Users”： 在这里，可以看到 之前（上一篇文章）添加的用户：user1。 点击 “ID”，然后转到 “Attributes” 选项卡，添加一个新的属性，即表示出生日期的 “DOB”： 点击 “Save” 后，自定义属性就会添加到用户信息中。 接下来，将此属性作为自定义 Claim 添加到映射中，以便它在用户 Token 的 JSON Payload 中可用。 为此，需要进入管理控制台的 “应用客户端”。回想一下 之前 创建的客户端 login-app： 点击它，然后选择 “Client scopes” 选项卡。在 “Client scopes” 页面点击 “login-app-dedicated” 链接，进入 “Mappers” 选项卡。点击 “Configure a new mapper”，选择 “User Attribute” 创建新 mapper： https://springdoc.cn/spring-boot-keycloak/ Mon, 11 Dec 2023 11:06:03 +0800 https://springdoc.cn/spring-boot-keycloak/ 1、概览 本文将带你了解如何设置 Keycloak 服务器，以及如何使用 Spring Security OAuth2.0 将 Spring Boot 应用连接到 Keycloak 服务器。 2、Keycloak 是什么？ Keycloak 是针对现代应用和服务的开源身份和访问管理解决方案。 Keycloak 提供了诸如单点登录（SSO）、身份代理和社交登录、用户联盟、客户端适配器、管理控制台和账户管理等功能。 本文使用 Keycloak 的管理控制台，使用 Spring Security OAuth2.0 设置和连接 Spring Boot。 3、设置 Keycloak 服务器 设置和配置 Keycloak 服务器。 3.1、下载和安装 Keycloak 有多种发行版可供选择，本文使 Keycloak-22.0.3 独立服务器发行版。点击 这里 从官方下载。 下载完后，解压缩并从终端启动 Keycloak： unzip keycloak-22.0.3.zip cd keycloak-22.0.3 bin/kc.sh start-dev 运行这些命令后，Keycloak 会启动服务。如果你看到一行类似于 Keycloak 22.0.3 [...] started 的内容，就表示服务器启动成功。 打开浏览器，访问 http://localhost:8080，会被重定向到 http://localhost:8080/auth 以创建管理员进行登录： 创建一个名为 initial1 的初始管理员用户，密码为 zaq1!QAZ。点击 “Create”后，可以看到 “User Created” 的提示信息。 现在进入管理控制台。在登录页面，输入 initial 管理员用户凭证： https://springdoc.cn/openapi-dates/ Mon, 11 Dec 2023 10:26:50 +0800 https://springdoc.cn/openapi-dates/ 1、简介 本文将带你了解如何在 OpenAPI 文件中声明日期（Date）。特别是在使用 Swagger 实现的情况下，这将使我们能够在调用外部 API 时以标准化的方式管理输入和输出日期。 2、Swagger 和 OAS Swagger 是一组工具，实现了 OpenAPI Specification（OAS），它是一种与编程语言无关的接口，用于文档化 RESTful API。这使我们能够了解任何服务的功能，而无需访问源代码。 要实现这一点，需要在项目中创建一个文件，通常是 YAML 或 JSON，使用 OAS 描述 API。然后，使用 Swagger 工具： 通过浏览器（Swagger 编辑器）编辑规范 自动生成 API 客户库（Swagger Codegen） 显示自动生成的文档（Swagger UI） OpenAPI 文件示例 中包含了不同的部分的示例，本文重点关注模型定义。 3、定义日期（Date） 使用 OAS 定义一个 User 实体： components: User: type: "object" properties: id: type: integer format: int64 createdAt: type: string format: date description: Creation date example: "2021-01-30" username: type: string 定义日期： type 等于 string format 字段，指定格式为日期（Date） 在本例中，使用 format: date 来描述 createdAt。这使用 ISO 8601 格式的日期。 https://springdoc.cn/spring-boot-and-querydsl/ Sun, 10 Dec 2023 14:32:42 +0800 https://springdoc.cn/spring-boot-and-querydsl/ QueryDSL 是一个用于构建类型安全查询的开源 Java ORM 框架。它提供了一种 Fluent 风格的 API 来构建和执行数据库查询，并提供了编译时类型检查，以避免常见的查询错误。QueryDSL 支持多种数据库，包括关系型数据库和 NoSQL 数据库，可以与多个持久化框架（如 JPA、Hibernate 等）整合使用。它简化了查询的编写过程，使得查询代码更易于理解、维护和重用。 QueryDSL 在 Spring Boot 中通常配合 Spring Data JPA 使用，它会根据定义的 JPA Entity 类自动生成对应的查询类。通过查询类，除了可以快速地进行基本的 CRUD 操作外还支持 JOIN、GROUP、子查询等复杂的检索。而这一切都无需编写任何 SQL 语句，代码即 SQL。 本文将会带你了解如何在 Spring Boot 中整合 QueryDSL + Spring Data JPA，以及 QueryDSL 的常见用法。 示例项目 本文使用到的软件版本： Java：21 Spring Boot：3.2.0 MySQL：8.0.26 添加依赖 创建 Spring Boot 应用，完整的 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> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>3.2.0</version> <relativePath /> <! https://springdoc.cn/spring-valid-vs-validated/ Sun, 10 Dec 2023 13:43:07 +0800 https://springdoc.cn/spring-valid-vs-validated/ 1、概览 本文将带你了解 Spring 中 @Valid 和 @Validated 注解的用法和它们之间的区别。 在大多数应用中，验证用户输入是常见的功能。在 Java 生态系统中，一般使用 Java Standard Bean Validation API 来支持这一点，从 Spring 4.0 版本开始，它就与 Spring 完美集成。@Valid 和 @Validated 注解就源自于这个 Standard Bean API。 2、@Valid 和 @Validated 注解 在 Spring 中，通常使用 JSR-303 的 @Valid 注解进行方法级验证，以及用于标记成员属性以进行验证。不过，该注解不支持分组验证。 分组（Group）可以帮助限制在验证过程中应用的约束条件。一个特定的使用案例是 UI 引导（UI wizards）。在第一步中，可能会有一组特定的字段。在后续步骤中，可能还有同一个 Bean 的另一组字段。因此，需要在每个步骤中对这些有限的字段应用约束条件，但是 @Valid 无法支持这样的功能。 对于分组级（Group-Level）验证，必须使用 Spring 的 @Validated，它是 JSR-303 的 @Valid 的变体，用于方法级。对于成员属性的标记，继续使用 @Valid 注解就行。 3、示例 使用 Spring Boot 开发一个简单的用户注册表单。 首先，只有 name 和 password 属性： public class UserAccount { @NotNull @Size(min = 4, max = 15) private String password; @NotBlank private String name; // 构造函数、Get、Set 省略 } 接下来是 Controller。在 saveBasicInfo 方法参数上使用 @Valid 注解来验证用户输入： https://springdoc.cn/spring-mvc-send-json-parameters/ Sun, 10 Dec 2023 11:32:58 +0800 https://springdoc.cn/spring-mvc-send-json-parameters/ 1、概览 本文将带你了解如何在 Spring MVC 中处理 POST 和 GET 请求中发送 JSON 参数。 2、Spring MVC 中的 JSON 参数 使用 JSON 发送或接收数据是 Web 开发人员的常见做法。JSON 字符串的分层结构为 HTTP 请求参数提供了一种更紧凑、更易于人类阅读的表示方式。 默认情况下，Spring MVC 通过了一系列内置的底层 Property Editor 为 String 等简单数据类型提供开箱即用的数据绑定。 但是，在实际项目中，可能需要绑定更复杂的数据类型。例如：将 JSON 参数映射到 Model Object。 3、使用 POST 请求发送 JSON Spring 提供了一种简单的方式来处理 POST 请求发送 JSON 数据。内置的 @RequestBody 注解可以自动将请求体中的 JSON 数据反序列化为特定的 Model 对象。 通常情况下，无需自己解析请求体，Spring MVC 会使用 Jackson 库来完成所有的工作。 首先，创建一个 Model 对象来表示传递的 JSON 数据。例如 Product 类： public class Product { private int id; private String name; private double price; // 构造函数、get、set 方法省略 } 其次，定义一个接受 POST 请求的 Spring Handler 方法： https://springdoc.cn/spring-boot-no-web-server/ Sun, 10 Dec 2023 11:04:25 +0800 https://springdoc.cn/spring-boot-no-web-server/ 1、简介 Spring Boot 是一个出色、流行的框架，可以快速创建适用于各种用例的 Java 应用。其中最常见用法之一是使用嵌入式 Servlet 容器来作为 Web 服务器。 Spring Boot 也可以用于许多不需要 Web 服务器的应用，如：命令行应用、作业调度、批处理或流处理应用等。 本文将带你了解在没有 Web 服务器的情况下使用 Spring Boot 的几种不同方式。 2、依赖 防止 Spring Boot 应用启动嵌入式 Web 服务器的最简单方法就是不在依赖中包含 Web Server Starter。 这意味着在 Maven POM 或 Gradle build 文件中都不会包含 spring-boot-starter-web 依赖。相反，使用更基本的 spring-boot-starter 依赖来替代它。 注意，Tomcat 依赖有可能作为传递依赖包含在应用中。在这种情况下，可能需要将 Tomcat 从包含它的依赖中排除。 3、修改 Spring Application 另一种禁用 Spring Boot 内嵌 Web 服务器的方法是使用代码。 使用 SpringApplicationBuilder： new SpringApplicationBuilder(MainApplication.class) .web(WebApplicationType.NONE) .run(args); 或者，可以使用 SpringApplication： SpringApplication application = new SpringApplication(MainApplication.class); application.setWebApplicationType(WebApplicationType.NONE); application.run(args); 无论哪种方式，都可以在 classpath 上保留可用的 Servlet 和容器 API。这意味着仍然可以在不启动 Web 服务器的情况下使用 Web 服务器库。例如，使用它们来编写测试或在自己的代码中使用它们的 API，这就非常有用。 https://springdoc.cn/spring-boot-characterencodingfilter/ Sun, 10 Dec 2023 10:51:27 +0800 https://springdoc.cn/spring-boot-characterencodingfilter/ 1、概览 本文将会带你了解 Spring Boot 中 CharacterEncodingFilter 的作用及其用法。 2、CharacterEncodingFilter CharacterEncodingFilter 是一个 Servlet Filter，可帮助我们为请求（Request）和响应（Response）指定字符编码。当浏览器未设置字符编码或我们希望对请求和响应进行特定处理时，该过滤器就非常有用。 3、实现 来看看如何在 Spring Boot 应用中配置该过 Filter。 首先，创建 CharacterEncodingFilter： CharacterEncodingFilter filter = new CharacterEncodingFilter(); filter.setEncoding("UTF-8"); filter.setForceEncoding(true); 在本例中，将编码设置为了 UTF-8，你也可以根据需要设置其他编码。 这里还使用了 forceEncoding 属性，无论浏览器请求中是否存在编码，都强制执行指定的编码。由于该标志设置为 true，提供的编码也将应用于响应的编码。 最后，使用 FilterRegistrationBean 注册 Filter，它提供了配置来将 Filter 实例注册为过滤器链（Filter Chain）的一部分： FilterRegistrationBean registrationBean = new FilterRegistrationBean(); registrationBean.setFilter(filter); registrationBean.addUrlPatterns("/*"); return registrationBean; 在非 Spring Boot 的应用中，可以在 web.xml 文件中添加该 Filter，以获得相同的效果。 4、总结 本文介绍了 Spring 中 CharacterEncodingFilter 的作用以及配置方法。 Ref：https://www.baeldung.com/spring-boot-characterencodingfilter https://springdoc.cn/spring-boot-running-port/ Sun, 10 Dec 2023 10:26:40 +0800 https://springdoc.cn/spring-boot-running-port/ 1、概览 Spring Boot 应用嵌入了一个 Web 服务器，有时候我们可能希望在运行时获取 HTTP 端口。 本文将带你了解如何在 Spring Boot 应用中以编程式的方式获取 HTTP 端口。 2、示例 2.1、Spring Boot 应用 创建一个简单的 Spring Boot 应用示例，演示如何在运行时获取 HTTP 端口： @SpringBootApplication public class GetServerPortApplication { public static void main(String[] args) { SpringApplication.run(GetServerPortApplication.class, args); } } 2.2、设置端口号的两种方式 通常，配置 Spring Boot 应用 HTTP 端口的最直接方法是在配置文件 application.properties 或 application.yml 中定义端口。 例如，在 application.properties 文件中，可以将 7777 设置为应用的运行端口： server.port=7777 另外，也可以不定义固定端口，而是通过将 server.port 属性值设置为 0，让 Spring Boot 应用在随机端口上运行： server.port=0 3、运行时获取固定端口 创建一个 properties 文件 application-fixedport.properties，并在其中定义固定端口 7777： https://springdoc.cn/java-http-response-body-as-string/ Sat, 09 Dec 2023 18:03:38 +0800 https://springdoc.cn/java-http-response-body-as-string/ 1、简介 本文介绍了以字符串形式读取 HTTP 响应体的几种方式。 2、HttpClient Java 11 中添加了 HttpClient，用于访问 Web 资源。与 HttpURLConnection 不同的是，HttpClient 除了支持 HTTP/1.1 和 HTTP/2 外，它还提供同步和异步请求类型。 HttpClient 提供了一个现代化的 API，具有很大的灵活性和强大的功能。该 API 由三个核心类组成：HttpClient、HttpRequest 和 HttpResponse。 HttpResponse 描述了 HttpRequest 调用的结果。HttpResponse 并非直接创建，而是在完全接收到正文（Body）后才可用。 首先创建 HttpClient 和 HttpRequest 对象： HttpClient client = HttpClient.newHttpClient(); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(DUMMY_URL)) .build(); 然后，使用 BodyHandlers 并调用 ofString() 方法返回 String 响应： HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); 3、HttpURLConnection HttpURLConnection 是一个轻量级 HTTP 客户端，用于通过 HTTP 或 HTTPS 协议访问资源，它允许创建一个 InputStream。获得 InputStream 后，就可以像读取普通本地文件一样读取它。 在 Java 中，可以用来访问互联网的主要类是 java. https://springdoc.cn/netflix-feign-vs-openfeign/ Sat, 09 Dec 2023 17:02:45 +0800 https://springdoc.cn/netflix-feign-vs-openfeign/ 1、概览 本文将会带你了解 Spring Cloud Netflix Feign 与 Spring Cloud OpenFeign 之间的区别。 2、Feign 通过 Feign 提供的注解支持，我们只需要定义接口就可以实现 Web 客户端，非常简单。 最初，Feign 由 Netflix 创建并发布，是其 Netflix OSS 项目的一部分。如今，它已成为一个开源项目。 2.1、Spring Cloud Netflix Feign Spring Cloud Netflix 将 Netflix OSS 产品集成到 Spring Cloud 生态系统（全家桶）中。其中包括 Feign、Eureka、Ribbon 以及大量其他工具和实用程序。Feign 被单独定义在一个 Spring Cloud Starter 中，以便只使用 Feign。 2.2、OpenFeign 后来，Netflix 决定停止在内部使用 Feign 并停止其开发。根据这一决定，Netflix 将 Feign 完全转移到开源社区的一个名为 OpenFeign 的新项目中。 幸运的是，它继续得到开源社区的大力支持，并推出了许多新功能和更新。 2.3、Spring Cloud OpenFeign 同样，Spring Cloud OpenFeign 将 OpenFeign 项目集成到 Spring Cloud 生态系统中。 这种集成增加了对 Spring MVC 注解的支持，并提供相同的 HttpMessageConverter。 https://springdoc.cn/spring-componentscan-vs-enableautoconfiguration/ Sat, 09 Dec 2023 16:37:13 +0800 https://springdoc.cn/spring-componentscan-vs-enableautoconfiguration/ 1、简介 本文将带你了解 Spring Boot 中 @ComponentScan 和 @EnableAutoConfiguration 注解的作用以及它们之间的区别。 2、Spring 注解 注解使 Spring 中依赖注入的配置变得更容易。可以在类和方法上使用 Spring Bean 注解来定义 Bean，而不是使用 XML 配置文件。之后，Spring IoC 容器会配置和管理 Bean。 本文主要关注如下注解： @ComponentScan：用于扫描带有注解的 Spring 组件。 @EnableAutoConfiguration：用于启用自动配置。 3、它们的区别 这俩注解的主要区别在于 @ComponentScan 会扫描 Spring 组件，而 @EnableAutoConfiguration 则用于自动配置 Spring Boot 应用中存在于 classpath 中的 Bean。 3.1、@ComponentScan 在开发应用时，需要告诉 Spring 框架如何查找受 Spring 管理的组件。@ComponentScan 使 Spring 能够扫描配置、Controller、Service 和我们定义的其他组件。 其中，@ComponentScan 注解与 @Configuration 注解一起使用，用于指定 Spring 扫描组件的包： @Configuration @ComponentScan public class EmployeeApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication. https://springdoc.cn/spring-transaction-active/ Sat, 09 Dec 2023 10:50:28 +0800 https://springdoc.cn/spring-transaction-active/ 1、概览 本文将带你了解在代码中检测 Spring 事务的几种方法。 2、事务配置 要在 Spring 中运行事务，必须启用事务管理。如果使用的是Spring Boot 项目，并且依赖了 spring-data- 或 spring-tx，Spring 会默认启用事务管理。否则，必须手动启用事务并明确提供事务管理器（Transaction Manager）。 首先，需要在 @Configuration 类中添加 @EnableTransactionManagement 注解。这样，在项目中就可以使用 Spring 注解驱动的事务管理了。 接下来，必须提供 PlatformTransactionManager 或 ReactiveTransactionManager Bean。该 Bean 需要一个数据源。可以选择使用一些常用库，如 H2 或 MySQL 库。这不是本文的重点。 启用事务后，就可以使用 @Transactional 注解来开启事务。 3、TransactionSynchronizationManager Spring 提供了一个名为 TransactionSychronizationManager 的类。该类有一个名为 isActualTransactionActive() 的静态方法可以让我们知道自己是否处于事务。 测试如下，用 @Transactional 注解一个测试方法。在方法中断言 isActualTransactionActive() 返回 true： @Test @Transactional public void givenTransactional_whenCheckingForActiveTransaction_thenReceiveTrue() { assertTrue(TransactionSynchronizationManager.isActualTransactionActive()); } 同样，删除 @Transactional 注解时，测试应断言返回 false： @Test public void givenNoTransactional_whenCheckingForActiveTransaction_thenReceiveFalse() { assertFalse(TransactionSynchronizationManager.isActualTransactionActive()); } 4、Spring 事务日志 也许你并不需要以编程式的方式来检测事务，可能只是想在应用的日志中查看事务发生的时间，可以在 properties 文件中启用 Spring 的事务日志： https://springdoc.cn/spring-load-time-weaving/ Fri, 08 Dec 2023 12:17:58 +0800 https://springdoc.cn/spring-load-time-weaving/ 简介 本文将带你了解 Spring 加载时织入（Load-Time Weaving）是如何工作的，以便在运行时应用 Hibernate 字节码增强机制。 一般来说，字节码增强机制是在使用 Maven 或 Gradle 插件构建项目时应用的。 Domain Model 假设有以下 Attachment 实体，如下： @Entity @Table(name = "attachment") public class Attachment { @Id private Long id; private String name; @Enumerated @Column(name = "media_type") private MediaType mediaType; @Lob @Column(columnDefinition="BLOB") @Basic(fetch = FetchType.LAZY) private byte[] content; // get、set 和其他方法省略 } content 属性使用的是 FetchType.LAZY 抓取策略，但在 POJO 实体上无法懒加载实体属性，因此需要 Hibernate 字节码增强机制来实现这一目标。 Hibernate 字节码增强机制 Hibernate 字节码增强机制允许我们更改 JPA 实体的字节码，这样就可以拦截 getter 和 setter 方法调用，从而达到以下目的 懒加载属性 记录实体的修改 如上所述，字节码增强机制是通过 Maven 或 Gradle 插件配置的，该插件会在项目构建时增强实体类。 https://springdoc.cn/getting-started-with-spring-cloud-azure/ Fri, 08 Dec 2023 10:17:47 +0800 https://springdoc.cn/getting-started-with-spring-cloud-azure/ 本文将会带你了解如何使用 Spring Cloud 来简化 Spring Boot 应用与 Azure 服务之间的整合，以及如何利用 Azure Spring Apps 服务在 Azure 上部署、运行和管理应用。本文中的示例 Spring Boot 应用将数据存储在 Azure Cosmos DB 服务中，并在 Public URL 下公开一些 REST 端点。我们可以在本地运行它并连接远程服务，也可以将它部署到云上并在同一虚拟网络下连接这些内部服务。 如果你需要了解 Spring Cloud，可以参阅 “Spring Boot 3 整合 Spring Cloud 开发微服务应用”。也推荐看一看 Spring Cloud Azure 文档，以便对主要概念有一个基本的了解。 架构 我们的架构非常简单。如上所述，我们有一个在 Azure 上运行并连接 Cosmos DB 的 Spring Boot 应用（图中为 account-service）。它提供一些 REST 端点，用于添加、删除或搜索由 Cosmos DB 支持的账户。它还将所需的全部配置（如 Cosmos DB 地址和凭证）存储在 Azure App Configuration 服务中。该应用程序由 Azure Spring Apps 服务管理。架构图如下： 源码 如果你想自己尝试，可以克隆我的 GitHub 仓库。本文使用的 Spring Boot 应用位于 microservices/account-service 目录中。进入该目录后，只需按照说明操作即可。 https://springdoc.cn/spring-boot-swagger-jwt/ Fri, 08 Dec 2023 10:03:29 +0800 https://springdoc.cn/spring-boot-swagger-jwt/ 1、简介 本文将带你了解如何在 Spring Boot 中配置 Swagger UI，使其在调用 API 时包含 JWT（JSON Web Token）。 2、Maven 依赖 本例使用 springdoc-openapi-ui 库，它包含了使用 Swagger 和 Swagger UI 所需的所有依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springdoc</groupId> <artifactId>springdoc-openapi-ui</artifactId> <version>1.7.0</version> </dependency> 3、Swagger 配置 首先，需要配置 JWT SecurityScheme： private SecurityScheme createAPIKeyScheme() { return new SecurityScheme().type(SecurityScheme.Type.HTTP) .bearerFormat("JWT") .scheme("bearer"); } 然后，配置 OpenAPI Bean，包含 API Info 和 Security Scheme： @Bean public OpenAPI openAPI() { return new OpenAPI().addSecurityItem(new SecurityRequirement(). addList("Bearer Authentication")) .components(new Components().addSecuritySchemes ("Bearer Authentication", createAPIKeyScheme())) . https://springdoc.cn/spring-boot-dispatcherservlet-web-xml/ Fri, 08 Dec 2023 09:27:06 +0800 https://springdoc.cn/spring-boot-dispatcherservlet-web-xml/ 1、概览 DispatcherServlet 是 Spring Web 应用的前端控制器（Front Controller）。它用于在 Spring MVC 中创建 Web 应用和 REST 服务。在传统的 Spring Web 应用中，该 Servlet 是在 web.xml 文件中定义的。 本文将会带你了解如何在 Spring Boot 项目中配置 DispatcherServlet，以及如何配置 web.xml 中的 Filter、Servlet 和 Listener。 2、Maven 依赖 首先，在 pom.xml 文件中添加 spring-boot-starter-web Maven 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> 3、DispatcherServlet DispatcherServlet 接收所有 HTTP 请求，并将其调度给 Controller 类。 在 Servlet 3.x 规范发布之前，DispatcherServlet 会在 Spring MVC 应用的 web.xml 文件中注册。自 Servlet 3.x 规范发布后，可以使用 ServletContainerInitializer 以编程方式注册 Servlet。 web.xml 文件中的 DispatcherServlet 配置示例： https://springdoc.cn/spring-boot-old-version/ Thu, 07 Dec 2023 18:54:56 +0800 https://springdoc.cn/spring-boot-old-version/ Spring Initializr（start.spring.io）是由 Spring Boot 官方提供的一个开源的 Spring Boot 项目初始化器。它提供了一个简单易用的界面来创建和配置 Spring 项目的初始代码。通过这个网站，开发者可以选择所需的 Spring Boot 版本、语言、构建工具（如 Maven 或 Gradle）、依赖和其他项目设置。 由于 Spring Boot 飞速发展，紧跟官方更新的 Spring Initializr 中可选择的 Spring Boot 版本、Java 版本也在随之迭代升级。所以，通过 Spring Initializr 可能无法选择旧版本的 Spring Boot。 截止撰稿时，start.spring.io 中最低的 Spring Boot 版本为 3.1.6，而目前大多数人用的仍然是 Spring Boot 2。 本文将会带你了解如何通过 start.spring.io 创建旧版本的 Spring Boot 项目。 手动修改版本号 你可以直接从 start.spring.io 创建任意 Spring Boot 和 Java 版本的 Spring Boot 项目，然后手动修改 pom.xml 或者 build.gradle 中的版本配置即可： 以 Maven 项目为例，只需要修改 pom.xml 中的 2 个配置元素即可： https://springdoc.cn/spring-boot-kafka-testing/ Thu, 07 Dec 2023 11:05:11 +0800 https://springdoc.cn/spring-boot-kafka-testing/ 1、概览 Apache Kafka 是一个功能强大、分布式、容错的流处理系统。在之前的教程中，介绍了 如何在 Spring 中整合、使用 Kafka。 本文将在 上一节 的基础上带你了解如何编写可靠、独立的集成测试，而不依赖于外部运行的 Kafka 服务器。 2、依赖 在 pom.xml 中添加标准的 spring-kafka 依赖： <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>2.7.2</version> </dependency> 以及两个专门用于测试的依赖，spring-kafka-test 和 Testcontainers Kafka（注意，都是 Test Scope）。 <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka-test</artifactId> <version>2.6.3.RELEASE</version> <scope>test</scope> </dependency> <dependency> <groupId>org.testcontainers</groupId> <artifactId>kafka</artifactId> <version>1.19.3</version> <scope>test</scope> </dependency> 3、简单的 Kafka 生产者-消费者应用 这是一个标准的 Spring Boot 应用，Application 类如下： @SpringBootApplication public class KafkaProducerConsumerApplication { public static void main(String[] args) { SpringApplication.run(KafkaProducerConsumerApplication.class, args); } } 3.1、生产者设置 接下来，创建 Producer bean，用它来向指定的 Kafka Topic 发送消息： https://springdoc.cn/docker-layers-spring-boot/ Thu, 07 Dec 2023 10:01:59 +0800 https://springdoc.cn/docker-layers-spring-boot/ 1、简介 Docker 是创建独立应用的事实标准。从 2.3.0 版开始，Spring Boot 包含了多项增强功能，可帮助我们创建高效的 Docker 镜像。例如：它允许将应用分解成不同的层。 换句话说，源代码位于自己的层中。因此，它可以独立重建，从而提高效率并缩短启动时间。本文将带你了解如何利用 Spring Boot 重用 Docker 层。 2、Docker 中的分层 jar Docker 容器由基础镜像和额外的层组成。一旦层构建完成，它们将保持缓存状态。因此，后续的生成速度会更快： 对底层层级的更改也会重新构建上层层级。因此，不经常更改的层级应保持在底部，而经常更改的层级应放在顶部。 同样，Spring Boot 允许将工件（构建产物）内容映射到层中。默认的层映射如下： 你可以看到，应用有自己的层。修改源代码时，只会重新构建独立的层。loader 和依赖保持缓存，从而减少了 Docker 镜像的创建和启动时间。接下来看看如何使用 Spring Boot 实现这一点！ 3、Spring Boot 创建高效的 Docker 镜像 在传统的构建 Docker 镜像的方式中，Spring Boot使用的是 “fat jar” 方法。一个工件就包含了所有依赖项和应用源代码。因此，源代码的任何变化都会迫使我们重建整个层。 3.1、Spring Boot 分层配置 Spring Boot 2.3.0 版引入了两个新功能来改进 Docker 镜像的生成： Buildpack 支持提供了应用的 Java 运行时环境，因此现在可以跳过 Dockerfile，并自动构建 Docker 镜像。 分层 JAR 可以帮助我们最大限度地利用 Docker 层的生成 在本文中，我们将对分层 JAR 方法进行扩展。 首先，在 Maven 中设置分层 JAR 。在打包工件时，生成层。 https://springdoc.cn/spring-cloud-2023-0-0-aka-leyton-is-now-available/ Thu, 07 Dec 2023 09:10:11 +0800 https://springdoc.cn/spring-cloud-2023-0-0-aka-leyton-is-now-available/ Spring Cloud 2023.0.0（代号 Leyton）RELEASE 版本已发布。你可以在 Maven Central 中找到该版本。 欲了解更多细节，可以查阅 2023.0 发布说明。 2023.0 版本中的显著变化 此版本基于 Spring Boot 3.2.0。 点击 此处 查看 2023.0.0 中的所有 issues。 Spring Cloud Gateway 2023.0 中包含与 Servlet/Spring MVC 兼容的 Spring Gateway Server MVC（issue，初始 PR） Gateway Actuator 发现功能增强 （PR 3147） Spring Cloud Function 现在可以将 REST 应用程部署为 AWS Lambdas 或 Azure Functions 使用 spring-cloud-function-web 将函数（Function）部署为 REST 端点时的 CRUD 映射 Spring Cloud Openfeign 支持 Java HttpClient（#689） Spring Cloud Commons 重新启动时的刷新范围（Refresh Scope） - 为适应 JVM 检查点重启时的环境变化而量身定制的功能（PR 1266） 为新的 RestClient 提供负载均衡支持 （1293） 确定性子集负载均衡算法，用于限制实例数量（1288）。 Spring Cloud Config Config Server 支持 Native image（PR 2361） Spring Cloud Kubernetes 将 fabric8 升级至 6. https://springdoc.cn/cds-with-spring-framework-6-1/ Wed, 06 Dec 2023 15:43:13 +0800 https://springdoc.cn/cds-with-spring-framework-6-1/ 正如 官方文档 所述，类数据共享（CDS）通过将类元数据缓存在 Archive（归档/存档） 文件中，使其可以快速预加载到新启动的 JVM 中，从而帮助缩短 JVM 的启动时间和内存占用。这加快了类加载速度，而类加载速度是启动时间的一个重要因素。大多数最新的 JDK 发行版中预先打包了默认的 CDS 归档，其中包含了常见 JDK 类的元数据。你也可以创建自定义的 CDS 归档，以加快类在自己应用中的加载速度。 GraalVM 原生镜像 和 Project CRaC 都能让 Spring Boot 应用在几十毫秒内启动。那么，为什么要关注 CDS 呢？ 主要有三个原因： 它是 OpenJDK 主线中成熟且可用于生产的技术，与 GraalVM 和 Project CRaC 相比，它更易于使用，因为它具有较少的限制和副作用。 正如 Brian Goetz 在他在 Devoxx 上的 Project Leyden 演讲 中提到的：“大多数人今天不使用 CDS，但可能应该使用，因为他们可以通过相对较少的工作获得合理的启动性能提升。” 在每一个新的 JVM 版本中，这项技术都会变得越来越好，Project Leyden 的目标是在不久的将来增加更多的优势。 接下来，让我们一起探究 CDS 能为你的 Spring 应用带来什么？ 在 Spring 6.1 中引入 CDS 初始支持 Spring 6.1 带来了一个新的 “类数据共享” 文档章节，解释了优化应用的两个步骤： 使用新增的 -Dspring. https://springdoc.cn/thymeleaf-variables/ Wed, 06 Dec 2023 15:15:49 +0800 https://springdoc.cn/thymeleaf-variables/ 1、简介 本文将通过一个 Spring Boot 示例带你了解 Thymeleaf 中的变量。 2、Maven 依赖 要使用 Thymeleaf，需要添加 spring-boot-starter-thymeleaf 和 spring-boot-starter-web 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> 3、Web Controller 首先，创建一个带有 GET 端点的 Web Controller，该端点返回一个包含文章列表的页面。 @GetMapping 方法只接受一个参数 - Model。它包含所有可在 Thymeleaf 模板中使用的全局变量。在本例中，Model 只有一个参数，即文章列表。 Article 类由两个 String 字段（name 和 url）组成： public class Article { private String name; private String url; // 构造函数、get、set 方法省略 } Controller 方法的返回值应该是要渲染的 Thymeleaf 模板的名称。该名称应与 src/resource/template 目录中的 HTML 文件相对应。在本例中，就是 src/resource/template/articles-list.html。 Controller 如下： @Controller @RequestMapping("/api/articles") public class ArticlesController { @GetMapping public String allArticles(Model model) { model. https://springdoc.cn/spring-boot-postgresql-docker/ Wed, 06 Dec 2023 14:29:04 +0800 https://springdoc.cn/spring-boot-postgresql-docker/ 1、概览 本文将带你了解如何使用 Docker Compose 来运行 Spring Boot 和 PostgreSQL。 2、创建 Spring Boot 应用 从 Spring Initializer 创建 Spring Boot 项目，添加 PostgreSQL 驱动和 Spring Data JPA 依赖。下载生成的 ZIP 文件并解压到文件夹后，就可以运行应用了： ./mvnw spring-boot:run 应用启动失败，因为连接数据库失败： *************************** APPLICATION FAILED TO START *************************** Description: Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured. Reason: Failed to determine a suitable driver class 3、Dockerfile 在使用 Docker Compose 启动 PostgreSQL 之前，需要将 Spring Boot 应用转化为 Docker 镜像。第一步是将应用打包为 JAR 文件： https://springdoc.cn/spring-webflux/ Wed, 06 Dec 2023 13:41:29 +0800 https://springdoc.cn/spring-webflux/ 1、概览 Spring 5 引入了 Spring WebFlux 框架，为 Web 应用提供响应式编程支持。 本文将带你了解如何使用响应式 Web 组件 RestController 和 WebClient 创建一个小型响应式 REST 应用，以及如何使用 Spring Security 来保护响应式端点。 2、Spring WebFlux 框架 Spring WebFlux 内部使用 Project Reactor 及其 Publisher（发布者）实现、Flux 和 Mono。 WebFlux 支持两种编程模式： 基于注解的响应式组件 函数式路由和处理 本文重点介绍基于注解的响应式组件。 3、依赖 首先从 spring-boot-starter-webflux 依赖开始。 它会传递依赖其他所有的依赖： spring-boot 和 spring-boot-starter，用于基本的 Spring Boot 应用设置 spring-webflux 框架 响应式流（Reactive Stream）所需的 reactor-core 以及 reactor-netty <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> <version>3.1.2</version> </dependency> 可从 Maven Central 下载最新的 spring-boot-starter-webflux。 4、响应式 REST 应用 现在，使用 Spring WebFlux 构建一个非常简单的响应式 REST EmployeeManagement 应用： https://springdoc.cn/spring-boot-actuators/ Wed, 06 Dec 2023 10:51:06 +0800 https://springdoc.cn/spring-boot-actuators/ 1、概览 本文将带你了解 Spring Boot Actuator，以及如何在 Spring Boot 和 WebFlux 中使用、配置和扩展这个监控工具，充分利用响应式编程模型。 2、Actuator 是啥？ 从本质上讲，Actuator 为应用带来了生产就绪的功能。 有了 Actuator 后，监控应用程序、收集指标、了解流量或数据库状态就变得易如反掌。 这个库的主要好处是，可以获得生产级工具，而无需自己实际实现这些功能。 Actuator 主要公开应用的运行信息 - 健康状况、指标、信息、转储（dump）、环境等。它使用 HTTP 端点或 JMX Bean 与客户端进行交互。 一旦在 classpath 中添加了该依赖，多个端点就已经开箱即用。与大多数 Spring 模块一样，可以通过多种方式轻松配置或扩展它。 3、入门 首先，在 Spring Boot 项目中添加 spring-boot-actuator 依赖，以启用 Spring Boot Actuator。 Mave： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> 该依赖的版本号已经在 spring-boot-starter-parent 中声明了，所以只要你继承了 Parent 项目，不需要手动声明版本号。 Actuator 与技术无关，Actuator 将其模型定义为可插拔和可扩展的，而不依赖 MVC。因此，可以利用 MVC 和 WebFlux 作为底层 Web 实现，还可以通过实现正确的适配器来添加新的实现。也支持 JMX，无需任何额外代码即可暴露端点。 4、端点配置 4.2、默认端点和安全配置 Actuator 禁用了大部分端点。因此，默认情况下只有 /health 和 /info 这两个端点可用。 https://springdoc.cn/java-es-codec/ Tue, 05 Dec 2023 14:15:21 +0800 https://springdoc.cn/java-es-codec/ 在 上一文 一文中，介绍了如何在 Java 中使用 RSA 非对称加密算法 进行加密、解密、生成数字签名和验签。 和 “非对称加密算法” 对应的就是 “对称加密算法”。非对称加密算法（如 RSA）的密钥通常由 公钥 和 私钥 组成，且遵守公钥加密、私钥解密的模式。而对称加密算法则只有一个密钥，加密和解密都使用同一个密钥。 对称加密算法中，比较安全且流行的就是 AES 算法，本文将会带你了解如何在 Java 中使用 AES 对数据进行加密和解密。 AES 介绍 AES（Advanced Encryption Standard）是一种对称加密算法，也被称为高级加密标准。它是一种广泛使用的加密算法，具有高度的安全性和效率，已被广泛应用于各种领域，包括网络通信、数据存储和加密协议等。AES 使用相同的密钥进行加密和解密操作，因此被归类为对称加密算法。 密钥 可以使用 Java 中的 javax.crypto.KeyGenerator API 来生成随机的 AES 密钥。 package cn.springdoc.demo.test; import java.security.SecureRandom; import java.util.Base64; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; public class Main { public static void main(String[] args) throws Exception { // 获取 AES 密钥生成器 KeyGenerator keyGenerator = KeyGenerator.getInstance("AES"); // 设置密钥长度和随机源 keyGenerator. https://springdoc.cn/spring-mvc-tutorial/ Tue, 05 Dec 2023 13:31:07 +0800 https://springdoc.cn/spring-mvc-tutorial/ 1、概览 这是一个简单的 Spring MVC 教程，介绍如何通过基于 Java 的配置和 XML 配置来建立 Spring MVC 项目。 Spring MVC 依赖： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>${org.springframework.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${org.springframework.version}</version> </dependency> 2、Spring MVC 是啥？ 顾名思义，它是 Spring 框架中处理模型（Model）- 视图（View）- 控制器（Controller）或 MVC 模式的一个模块。它结合了 MVC 模式的所有优点和 Spring 的便利性。 Spring 使用其 DispatcherServlet 前控制器模式实现 MVC。 简而言之，DispatcherServlet 是将请求路由到预定目的地的主要控制器。Model 只是应用的数据，而视图则由各种模板引擎来表示。 3、使用 Java 配置的 Spring MVC 要通过 Java 配置类启用 Spring MVC 支持，只需添加 @EnableWebMvc 注解即可： @EnableWebMvc @Configuration public class WebConfig { /// ... } 这将设置 MVC 项目所需的基本支持，如注册处理器、映射器、类型转换器、验证支持、消息转换器和异常处理。 https://springdoc.cn/spring-aop-xml/ Tue, 05 Dec 2023 12:51:22 +0800 https://springdoc.cn/spring-aop-xml/ 1、简介 本文将带你了解 Spring 中的 AOP（面向切面编程），并学习如何在实际场景中使用这一强大工具。 在使用 Spring AOP 开发时，还可以利用 @AspectJ 的注解，但本文重点介绍 Spring AOP 基于 XML 的核心配置。 2、概览 AOP 是一种编程范式，旨在通过分离横切关注点来提高模块化程度。它通过在不修改代码本身的情况下为现有代码添加额外的行为来实现这一目标。 Spring 的 AOP 框架 可以帮助我们实现这些切面关注点。 3、Maven 依赖 首先，在 pom.xml 中添加 Spring 的 AOP 依赖： <!-- Spring Boot 应用 --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> </dependencies> <!-- Spring 应用 --> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>6.1.1</version> </dependency> </dependencies> 可以在 Maven 仓库中查询到最新的版本。 4、AOP 概念和术语 简要回顾一下 AOP 的特定概念和术语： 4.1、业务对象 业务对象是一个具有正常业务逻辑的普通类。 来看一个简单的业务对象示例，只需将两个数字相加： https://springdoc.cn/spring-cloud-gateway-guide/ Tue, 05 Dec 2023 11:17:08 +0800 https://springdoc.cn/spring-cloud-gateway-guide/ 1、概览 本文将带你了解 Spring Cloud Gateway 的主要功能，它是一个基于 Spring Boot 和 Project Reactor 的网关。 Spring Cloud Gateway 提供开箱即用的路由机制，通常用于微服务应用中，把多个服务隐藏在 “Facade”（门面设计模式）后面。 2、路由处理器 Spring Cloud Gateway 专注于路由请求，它将请求转发给网关 Handler Mapping，由其决定如何处理与特定路由相匹配的请求。 从一个快速示例开始，看看 Gateway Handler 如何使用 RouteLocator 解析路由配置： @Bean public RouteLocator customRouteLocator(RouteLocatorBuilder builder) { return builder.routes() .route("r1", r -> r.host("**.baeldung.com") .and() .path("/baeldung") .uri("http://baeldung.com")) .route(r -> r.host("**.baeldung.com") .and() .path("/myOtherRouting") .filters(f -> f.prefixPath("/myPrefix")) .uri("http://othersite.com") .id("myOtherID")) .build(); } 注意，有几个核心的 API： Route - 网关的主要 API。它由给定的标识（ID）、目的地（URI）和一组 Predicate 和 Filter 定义 Predicate - Java 8 Predicate ，用于使用 Header、方法或参数匹配 HTTP 请求 Filter - 标准的 Spring WebFilter 3、动态路由 与 Zuul 一样，Spring Cloud Gateway 也提供了将请求路由到不同服务的方法。 https://springdoc.cn/spring-integration-guide/ Tue, 05 Dec 2023 10:18:07 +0800 https://springdoc.cn/spring-integration-guide/ 1、简介 本文将通过一些实际的案例，带你了解 Spring Integration 的核心概念。 Spring Integration 提供了许多功能强大的组件，可大大增强企业架构内系统和流程的互联性。 2、设置 <dependency> <groupId>org.springframework.integration</groupId> <artifactId>spring-integration-core</artifactId> <version>5.1.13.RELEASE</version> </dependency> <dependency> <groupId>org.springframework.integration</groupId> <artifactId>spring-integration-file</artifactId> <version>5.1.13.RELEASE</version> </dependency> 你可以从 Maven Central 下载最新版本的 Spring Integration Core 和 Spring Integration File Support。 3、消息传递模式 这个库中的一个基本模式是消息传递（Messaging）。该模式围绕消息展开，消息是离散的数据负载（Discrete Payloads），通过预定义的通道从源系统或进程传递到一个或多个系统或进程。 从历史上看，这种模式是整合多个不同系统的最灵活方式，它可以： 几乎完全解耦集成所涉及的系统 允许集成中的参与系统完全不考虑彼此的底层协议、格式或其他实现细节 鼓励开发和重复使用参与集成的组件 4、消息集成的实际应用 举一个基本例子，将 MPEG 视频文件从指定文件夹复制到另一个配置文件夹： @Configuration @EnableIntegration public class BasicIntegrationConfig{ public String INPUT_DIR = "the_source_dir"; public String OUTPUT_DIR = "the_dest_dir"; public String FILE_PATTERN = "*.mpeg"; @Bean public MessageChannel fileChannel() { return new DirectChannel(); } @Bean @InboundChannelAdapter(value = "fileChannel", poller = @Poller(fixedDelay = "1000")) public MessageSource<File> fileReadingMessageSource() { FileReadingMessageSource sourceReader= new FileReadingMessageSource(); sourceReader. https://springdoc.cn/spring-5-webclient/ Mon, 04 Dec 2023 18:31:52 +0800 https://springdoc.cn/spring-5-webclient/ 1、概览 本文将带你了解如何使用 WebClient 和 WebTestClient，前者是一个 Spring 5 中引入的响应式 HTTP 客户端，而后者是一种用于测试的 WebClient。 2、WebClient 是啥？ 简而言之，WebClient 是一个接口，表示执行 Web 请求的主要入口点。 它是 Spring Web Reactive 模块的一部分，用于取代经典的 RestTemplate。此外，这个新的客户端是一个基于 HTTP/1.1 协议的响应式、非阻塞解决方案。 尽管它实际上是一个非阻塞客户端，而且属于 spring-webflux 库，但该解决方案同时支持 同步 和 异步 操作，因此也适用于在 Servlet 技术栈上运行的应用，通过阻塞操作来获得结果。当然，如果使用的是响应式技术栈，则不建议采用这种做法。 该接口只有一个实现，即我们将要使用的 DefaultWebClient 类。 3、依赖 在 Spring Boot 应用中，只需要添加 spring-boot-starter-webflux 依赖即可获得响应式 Web 的支持。 3.1、使用 Maven 构建 在 pom.xml 中添加以下依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> </dependency> 3.2、使用 Gradle 构建 build.gradle 文件中添加以下条目： dependencies { compile 'org.springframework.boot:spring-boot-starter-webflux' } 4、使用 WebClient 要使用 WebClient，我们需要了解如何： https://springdoc.cn/spring-boot-start/ Mon, 04 Dec 2023 17:12:44 +0800 https://springdoc.cn/spring-boot-start/ 1、概览 Spring Boot 是一个基于 Spring 的框架，旨在简化 Spring 应用的配置和开发过程，通过自动配置和约定大于配置的原则，使开发者能够快速搭建独立、生产级别的应用程序。 本文将带你了解 Spring Boot 的核心内容，从基本的项目创建开始，内容包括了：应用配置、Thymeleaf 视图配置、Spring Security 配置、持久层配置、Web 层 Controller 配置以及异常处理和测试。 2、设置 首先，使用 Spring Initializr 生成基础项目。 生成的项目依赖于 Spring Boot Parent 项目： <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <relativePath /> </parent> 初始依赖非常简单： <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>com.h2database</groupId> <artifactId>h2</artifactId> </dependency> 3、应用配置 创建 Main Application 类： @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } 这里使用的是 @SpringBootApplication 注解，这相当于同时使用了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 注解。 https://springdoc.cn/spring-retry-guide/ Mon, 04 Dec 2023 10:45:21 +0800 https://springdoc.cn/spring-retry-guide/ 1、概览 Spring Retry 提供了自动重新调用失败操作的能力。这在错误可能是短暂的（例如瞬时的网络故障）情况下非常有帮助。 本文将带你了解使用 Spring Retry 的各种方法：注解、RetryTemplate 和回调。 2、Maven 依赖 首先，在 pom.xml 文件中添加 spring-retry 以及 Spring AOP 依赖： <dependency> <groupId>org.springframework.retry</groupId> <artifactId>spring-retry</artifactId> <version>2.0.3</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>6.0.11</version> </dependency> 你可以在 Maven Central 获取 spring-retry 和 spring-aspects 依赖的最新版本。 3、启用 Spring Retry 要在应用中启用 Spring Retry，需要在 @Configuration 类中添加 @EnableRetry 注解： @Configuration @EnableRetry public class AppConfig { ... } 4、使用 Spring Retry 4.1、@Retryable 注解 使用 @Retryable 注解为方法添加重试功能： @Service public interface MyService { @Retryable void retryService(String sql); } 由于没有指定任何异常，因此将尝试重试所有异常。此外，一旦达到最大尝试次数，但仍有异常，就会抛出 ExhaustedRetryException。 https://springdoc.cn/inversion-control-and-dependency-injection-in-spring/ Mon, 04 Dec 2023 09:16:23 +0800 https://springdoc.cn/inversion-control-and-dependency-injection-in-spring/ 1、概览 本文将带你了解 IoC（控制反转）和 DI（依赖注入）的概念，以及如何在 Spring 中实现这些概念。 2、控制反转（IoC）是什么？ 控制反转（Inversion of Control）是软件工程中的一项原则，它将对象或程序部分的控制权转移到容器或框架中。在面向对象的编程中经常使用。 也有人叫 “反转控制”。 在传统编程中，我们使用自定义代码来调用库，而 IoC 则使框架能够控制程序的流程，并调用我们的自定义代码。框架使用了带有内置附加行为的抽象类来实现这一点。如果我们想添加自己的行为，就需要继承框架的类或插入自己的类。 这种架构的优势在于： 将任务的执行与任务的实现分离开来 更容易在不同的实现之间切换 程序的模块化程度更高 通过隔离组件或模拟其依赖，并允许组件通过 “约定” 进行通信，从而更轻松地测试程序 我们可以通过各种机制实现控制反转，例如：策略模式、服务定位模式、工厂模式和依赖注入（DI）。 3、依赖注入（DI）是什么？ 依赖注入是可以用来实现 IoC 的一种模式，其中被反转的控制是 设置对象的依赖。 将对象与其他对象 “装配” 起来，或将对象 “注入” 到其他对象中是由组装器（Assembler）而不是对象本身来完成的。 下面是我们在传统编程中创建依赖对象的方法： public class Store { private Item item; public Store() { item = new ItemImpl1(); // 实例化所需的依赖 } } 重写示例，通过使用 DI，而无需指定 Item 的实现： public class Store { private Item item; public Store(Item item) { this.item = item; } } 在接下来的章节中，将带你了解如何通过元数据（Metadata）来实现 Item。 https://springdoc.cn/spring-load-pem-rsa-key/ Sun, 03 Dec 2023 17:16:08 +0800 https://springdoc.cn/spring-load-pem-rsa-key/ 在 上一篇文章 中，我们介绍了如何使用 Java 生成 RSA 密钥对，以及如何使用 RSA 进行加密、解密和签名验签。 在实际情况中，RSA 加密、解密所使用的密钥对往往是已经生成好的，通常以 PEM（Privacy Enhanced Mail）格式存储。 PEM 是一种常见的文件格式，用于存储和传输加密的 证书、私钥 和其他安全相关的数据。 证书（Certificate）：用于存储公钥证书，通常以 .pem 或 .crt 为扩展名。 私钥（Private Key）：用于存储私钥，通常以 .pem 或 .key 为扩展名。 PEM 格式的文件通常以.pem为扩展名，它使用标头和尾部标记来界定不同类型的数据，并使用 Base64 编码将二进制数据转换为 ASCII 文本。 本文将带你了解如何在 Java 中使用 Spring 的 PemContent 工具类加载 PEM 格式的 RSA 证书和私钥为 PublicKey 和 PrivateKey 对象。 使用 OpenSSL 生成 RSA 私钥和证书 我们使用 OpenSSL 来生成示例所用的 RSA 私钥和证书。首先需要确保你在本机安装了 OpenSSL，并且正确地配置到了 PATH 环境变量。 OpenSSL 是一个开源的密码学工具库，被广泛应用于网络安全领域，用于创建和管理 SSL/TLS 连接、生成自签名证书、签发数字证书、进行加密通信等。 生成 2048 位的 RSA 私钥： https://springdoc.cn/spring-cloud-netflix-eureka/ Sun, 03 Dec 2023 15:36:56 +0800 https://springdoc.cn/spring-cloud-netflix-eureka/ 1、概览 本文将带你了解如何通过 Spring Cloud Netflix Eureka 来实现客户端服务发现。 客户端服务发现允许服务相互查找和通信，而无需硬编码主机名和端口。在这种架构中，唯一的 “固定点” 是服务注册中心（service registry,），每个服务都必须在注册中心中注册。 一个缺点是所有客户端必须实现特定的逻辑与这个注册中心进行交互。这就需要在实际请求之前进行一次额外的网络请求。 有了 Netflix Eureka，每个客户端都可以同时充当服务器，将自己的状态复制给已连接的对等服务。换句话说，客户端在服务注册中心中检索所有已连接对等服务的列表，并通过负载均衡算法向其他服务发出所有进一步请求。 要获知客户端的存在，它们必须向注册中心发送心跳信号。 为了实现本文的目标，需要实现三个微服务： 注册中心（Eureka Server） REST 服务，在注册中心中注册（Eureka Client） Web 应用，作为客户端（Spring Cloud Netflix Feign Client）来消费 REST 服务（从注册中心获取到服务） 2、Eureka 服务器 使用 Eureka Server 实现一个注册中心，很简单： 在依赖中添加 spring-cloud-starter-netflix-eureka-server 用 @EnableEurekaServer 对 @SpringBootApplication 进行注解，从而启用 Eureka 服务器 配置一些配置属性 一步步来： 首先，创建一个新的 Spring Boot 项目，并添加相应的依赖。 通过 spring-cloud-starter-parent Bom 管理组件的依赖版本。 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId> </dependency> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-parent</artifactId> <version>2021.0.3</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> 你可以在 Spring 的官方文档中查看 最新的 Spring Cloud 版本。 https://springdoc.cn/spring-security-csrf/ Sun, 03 Dec 2023 14:45:07 +0800 https://springdoc.cn/spring-security-csrf/ 1、概览 本文将带你了解什么是跨站请求伪造（CSRF）攻击？以及如何使用 Spring Security 来防范这些攻击。 2、两种简单的 CSRF 攻击行为 CSRF 攻击有多种形式。 2.1、GET 示例 假如下面这个 GET 请求，用于一个已登录的用户向指定的银行账户 1234 转账： GET http://bank.com/transfer?accountNo=1234&amount=100 如果攻击者想把钱从受害者的账户转到自己的账户（5678），他需要让受害者触发请求： GET http://bank.com/transfer?accountNo=5678&amount=1000 有多种方法可以实现这一点： 链接 - 攻击者可以说服/诱导受害者点击该链接，例如执行转账： <a href="http://bank.com/transfer?accountNo=5678&amount=1000"> 点击展示美女图片 </a> 图片 - 攻击者可能会使用 <img/> 标签，将目标 URL 作为图片来源。换句话说，甚至不需要点击。请求将在页面加载时自动执行： <img src="http://bank.com/transfer?accountNo=5678&amount=1000"/> 所以，涉及到敏感的业务，千万不能用 GET 请求。 2.2、POST 示例 假设转账 API 是一个 POST 请求。 POST http://bank.com/transfer accountNo=1234&amount=100 在这种情况下，<a> 和 <img/> 标签都不起作用。 攻击者需要使用 <form>： <form action="http://bank.com/transfer" method="POST"> <input type="hidden" name="accountNo" value="5678"/> <input type="hidden" name="amount" value="1000"/> <input type="submit" value="Show Kittens Pictures"/> </form> 然后，使用 JavaScript 自动提交表单： https://springdoc.cn/thymeleaf-in-spring-mvc/ Sat, 02 Dec 2023 18:58:34 +0800 https://springdoc.cn/thymeleaf-in-spring-mvc/ 1、概览 Thymeleaf 是一个 Java 模板引擎，用于处理和创建 HTML、XML、JavaScript、CSS 和文本。 本文将带你了解如何在 Spring 和 Spring Boot 应用中整合、使用 Thymeleaf。 该库具有极高的可扩展性，其天然的模板功能可以确保在没有后端的情况下制作模板原型。与其他流行的模板引擎（如 JSP）相比，这使得开发速度非常快。 2、Spring 整合 Thymeleaf 首先，来看看与 Spring 整合所需的配置。这需要使用 thymeleaf-spring 库。 在 Maven POM 文件中添加以下依赖： <dependency> <groupId>org.thymeleaf</groupId> <artifactId>thymeleaf</artifactId> <version>3.1.2.RELEASE</version> </dependency> <dependency> <groupId>org.thymeleaf</groupId> <artifactId>thymeleaf-spring5</artifactId> <version>3.1.2.RELEASE</version> </dependency> 注意，对于 Spring 4，必须使用 thymeleaf-spring4，而不是 thymeleaf-spring5。 通过 SpringTemplateEngine 类执行所有配置步骤。 可以在 Java 配置中将该类配置为 bean： @Bean @Description("Thymeleaf Template Resolver") public ServletContextTemplateResolver templateResolver() { ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(); templateResolver.setPrefix("/WEB-INF/views/"); templateResolver.setSuffix(".html"); templateResolver.setTemplateMode("HTML5"); return templateResolver; } @Bean @Description("Thymeleaf Template Engine") public SpringTemplateEngine templateEngine() { SpringTemplateEngine templateEngine = new SpringTemplateEngine(); templateEngine. https://springdoc.cn/spring-security-ldap/ Sat, 02 Dec 2023 18:38:02 +0800 https://springdoc.cn/spring-security-ldap/ 1、概览 本文将带你了解如何设置 Spring Security LDAP。 LDAP、即 Lightweight Directory Access Protocol（轻量级目录访问协议）的缩写，是一种开放的、厂商中立的协议，用于通过 Web 访问目录服务。 2、Maven 依赖 所需 Maven 依赖如下： <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-ldap</artifactId> </dependency> <dependency> <groupId>org.apache.directory.server</groupId> <artifactId>apacheds-server-jndi</artifactId> <version>1.5.5</version> </dependency> 注：使用 ApacheDS 作为 LDAP 服务器，这是一个可扩展、可嵌入的目录服务器。 3、Java 配置 Spring Security Java 配置： public class SecurityConfig { @Bean ApacheDSContainer ldapContainer() throws Exception { return new ApacheDSContainer("dc=baeldung,dc=com", "classpath:users.ldif"); } @Bean LdapAuthoritiesPopulator authorities(BaseLdapPathContextSource contextSource) { String groupSearchBase = "ou=groups"; DefaultLdapAuthoritiesPopulator authorities = new DefaultLdapAuthoritiesPopulator (contextSource, groupSearchBase); authorities.setGroupSearchFilter("(member={0})"); return authorities; } @Bean AuthenticationManager authenticationManager(BaseLdapPathContextSource contextSource, LdapAuthoritiesPopulator authorities) { LdapBindAuthenticationManagerFactory factory = new LdapBindAuthenticationManagerFactory (contextSource); factory. https://springdoc.cn/rest-template/ Sat, 02 Dec 2023 17:37:52 +0800 https://springdoc.cn/rest-template/ 1、概览 本文将带你了解如何使用 Spring REST 客户端 RestTemplate 发起各种类型的 HTTP 请求。 2、废弃警告 从 Spring Framework 5 开始，除了 WebFlux，Spring 还引入了一个名为 WebClient 的新 HTTP 客户端。 WebClient 是一种替代 RestTemplate 的现代 HTTP 客户端。它不仅提供传统的同步 API，还支持高效的非阻塞和异步方法。 如果要开发新的应用或迁移旧的应用，最好还是使用 WebClient。在未来版本中，RestTemplate 将被弃用。 3、使用 GET 检索资源 3.1、获取纯 JSON 格式 使用 getForEntity() API 发起 GET 请求： RestTemplate restTemplate = new RestTemplate(); String fooResourceUrl = "http://localhost:8080/spring-rest/foos"; ResponseEntity<String> response = restTemplate.getForEntity(fooResourceUrl + "/1", String.class); Assertions.assertEquals(response.getStatusCode(), HttpStatus.OK); 可以访问完整的 HTTP 响应，因此可以检查 HTTP 状态码是否成功，或者处理响应体： ObjectMapper mapper = new ObjectMapper(); JsonNode root = mapper. https://springdoc.cn/spring-boot-coordinated-restore-at-checkpoint/ Fri, 01 Dec 2023 15:16:47 +0800 https://springdoc.cn/spring-boot-coordinated-restore-at-checkpoint/ 上周 发布 的 Spring 6.1 和 SpringBoot 3.2 都全面支持 CRaC（Coordinated Restore at Checkpoint）。 CRaC（Coordinated Restore at Checkpoint），翻译过来应该是 “检查点协调恢复”，如果你想了解有关 CRaC 的更多信息，请参阅 这里。 CRaC 是一个 OpenJDK 项目，可以对运行中的 JVM（Java 虚拟机）进行 “快照”，并将其状态（包括应用）存储到磁盘中。然后，在另一个时间点，可以将 JVM 从保存的检查点恢复到内存中。借助这个功能，你可以启动应用、预热并创建检查点（Checkpoint）。从保存的检查点恢复到内存主要依靠磁盘 I/O，这意味着恢复速度非常快（在毫秒级范围内）。 本文使用 SpringBoot Petclinic 项目来测试 SpringBoot 3.2 对 CRaC 的支持。 前提条件 要在 SpringBoot 3.2 中使用 CRaC，需要具备以下三个条件 支持 CRaC 的 JVM org.crac 的依赖 存放检查点的文件夹 使用的 JDK（Java 开发包）是 Azul Zulu 21.0.1 + CRaC，可从 此处 获取。该 JDK 适用于 x64 和 aarch64 CPU 架构，以及 JDK 17 和 JDK 21。 https://springdoc.cn/spring-boot-change-request-body-before-controller/ Fri, 01 Dec 2023 14:23:41 +0800 https://springdoc.cn/spring-boot-change-request-body-before-controller/ 1、概览 本文将带你了解如何在 HTTP 请求到达 Spring Boot 应用的 Controller 之前对其进行修改。Web 应用和 RESTful Web 服务经常使用这种方式来解决常见问题，例如在传入的 HTTP 请求到达实际 Controller 之前对其进行转换或过滤。这促进了松散耦合，大大减少了开发工作量。 2、使用 Filter 通常，应用需要执行一些通用的操作，如身份认证、日志记录、转义 HTML 字符等。Filter 是解决在任何 Servlet 容器中运行的应用的这些通用问题的最佳选择。 Filter 工作方式如下： 在 Spring Boot 应用中，以固定顺序注册 Filter，以实现以下目的： 修改请求 记录请求日志 检查请求是否经过认证或是否存在恶意脚本 决定拒绝或将请求转发给下一个 Filter 或 Controller 假设我们要转义 HTTP 请求体中的所有 HTML 字符，以防止 XSS 攻击。 首先定义 Filter： @Component @Order(1) public class EscapeHtmlFilter implements Filter { @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { filterChain.doFilter(new HtmlEscapeRequestWrapper((HttpServletRequest) servletRequest), servletResponse); } } @Order 注解中的 value 值 1 表示所有 HTTP 请求首先通过 EscapeHtmlFilter Filter。还可以在 Spring Boot 配置类中定义 FilterRegistrationBean Bean 来注册 Filter，这可以为 Filter 定义 URL 模式。 https://springdoc.cn/spring-async-retry/ Fri, 01 Dec 2023 14:00:34 +0800 https://springdoc.cn/spring-async-retry/ 1、概览 有时，我们会通过异步的方式来提高应用的性能和响应能力。但是也需要考虑到偶尔故障的情况，如网络问题。此时，我们可以通过重试机制来重新调用。 本文将带你了解 Spring 对异步（async）和重试（retry）操作的支持以及如何在 Spring 应用中实现带有自动重试功能的异步执行。 2、Spring Boot 示例应用 构建一个简单的微服务，调用下游服务来处理一些数据。 2.1、Maven 依赖 添加 spring-boot-starter-web 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> 2.2、实现 Spring Service 实现 EventService 类，在 processEvents 方法中调用另一个服务的方法： public String processEvents(List<String> events) { downstreamService.publishEvents(events); return "Completed"; } 定义 DownstreamService 接口： public interface DownstreamService { boolean publishEvents(List<String> events); } 3、实现带重试功能的异步执行 使用 spring-retry 来实现带有重试功能的异步执行。 3.1、添加 Retry 依赖 在 pom.xm 中添加 spring-retry 依赖： <dependency> <groupId>org.springframework.retry</groupId> <artifactId>spring-retry</artifactId> <version>2.0.4</version> </dependency> 3.2、@EnableAsync 和 @EnableRetry 配置 添加 @EnableAsync 和 @EnableRetry 注解： https://springdoc.cn/spring-boot-spring-batch/ Fri, 01 Dec 2023 12:36:43 +0800 https://springdoc.cn/spring-boot-spring-batch/ 1、概览 Spring Batch 是一个强大的批处理框架，可用于开发健壮的批处理应用。 上一篇教程 介绍了 Spring Batch，本文将在此基础上带你了解如何使用 Spring Boot 设置和创建一个基本的批处理驱动应用。 2、Maven 依赖 首先，在 pom.xml 中添加 spring-boot-starter-batch 和 h2 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-batch</artifactId> <version>3.0.0</version> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.1.214</version> <scope>runtime</scope> </dependency> 3、定义简单的 Spring Batch Job 创建一个 Job，从 CSV 文件导入 coffee 清单，使用自定义 Processor 对其进行转换，并将最终结果存储到内存数据库中。 3.1、开始 首先，程序入口： @SpringBootApplication public class SpringBootBatchProcessingApplication { public static void main(String[] args) { SpringApplication.run(SpringBootBatchProcessingApplication.class, args); } } 可以看到，这是一个标准的 Spring Boot 应用。为了简单，一切配置都是使用默认值。 在 src/main/resources/application.properties 文件中定义如下属性： file.input=coffee-list.csv 该属性包含输入 coffee 列表的位置。每一行都包含 coffee 的品牌、产地和一些特征： https://springdoc.cn/introduction-to-spring-batch/ Fri, 01 Dec 2023 12:33:38 +0800 https://springdoc.cn/introduction-to-spring-batch/ 1、概览 本文将带你深入了解 Spring Batch。它是一个批处理框架，专为执行批处理作业而设计。 当前的 5.0.0 版本支持 Spring 6 和 Java 17。 2、工作流基础 Spring Batch 遵循传统的批处理架构，其中 Job Repository 负责 Job 的调度和交互。 一项工作（Job）可以有多个步骤（Step）。每个步骤通常都遵循 读取数据、处理数据 和 写入数据 的顺序。 当然，框架会在这里完成大部分繁重的工作，尤其是在处理 Job 的底层持久化时 - 本文使用 h2 作为 Job Repository。 2.1、应用示例 在本例中，我们需要将一些财务交易数据从 CSV 迁移到 XML。 输入文件的结构非常简单。 每行包含一笔交易，由用户名（username）、用户 ID（userid）、交易日期（transaction_date）和金额（transaction_amount）组成： username, userid, transaction_date, transaction_amount devendra, 1234, 31/10/2015, 10000 john, 2134, 3/12/2015, 12321 robin, 2134, 2/02/2015, 23411 3、Maven 依赖 本项目需要依赖 Spring Core、Spring Batch 和 H2 数据库： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-oxm</artifactId> <version>6. https://springdoc.cn/spring-boot-update-logger-level/ Wed, 29 Nov 2023 18:08:28 +0800 https://springdoc.cn/spring-boot-update-logger-level/ 在 Spring Boot 应用中，默认使用 Logback 来记录日志。可以在 application.yaml 或者是 logback-spring.xml 中配置 Logger 的日志级别。 有以下几个常见的日志级别（从低到高）： TRACE（跟踪）：最低级别的日志，用于输出详细的调试信息，通常用于追踪代码的执行路径。 DEBUG（调试）：用于输出调试信息，帮助开发人员调试应用程序。 INFO（信息）：用于输出一般性的信息，例如应用程序的启动信息、重要事件等。 WARN（警告）：用于输出警告信息，表示潜在的问题或不符合预期的情况，但不会影响应用程序的正常运行。 ERROR（错误）：最高级别的日志，用于输出错误信息，表示发生了一个错误或异常情况，可能会影响应用程序的正常运行。 级别越低，包含的信息越详细，级别越高，包含的信息越严重和重要。当设置日志级别时，只有达到或高于该级别的日志才会被记录和输出，而低于该级别的日志将被忽略。如：如果将日志级别设置为 INFO，则会记录和输出 INFO、WARN 和 ERROR 级别的日志，而 DEBUG 和 TRACE 级别的日志将被忽略。这有助于控制日志的详细程度和输出量，以适应特定的调试或生产环境要求。 Log4j 建议只使用 ERROR、WARN、INFO、DEBUG 四个级别。 以 ROOT Logger 的配置为例 在 application.yaml 中配置 logging: level: ROOT: DEBUG 在 logback-spring.xml 中配置 首先，需要在 application.yaml 中配置 logback-spring.xml 配置文件的位置： logging: config: classpath:logback-spring.xml 然后，在 logback-spring.xml 中配置 ROOT Logger 的日志级别： <configuration> <!-- 继承 Spring 预定义的 Logback 配置 --> <include resource="org/springframework/boot/logging/logback/base.xml"/> <! https://springdoc.cn/spring-boot-scheduled-websocket/ Wed, 29 Nov 2023 16:35:31 +0800 https://springdoc.cn/spring-boot-scheduled-websocket/ 1、概览 本文将带你了解如何在 Spring Boot 中实现定时地往浏览器推送 WebSockets 消息。 另一种方法是使用服务器发送事件 (SSE)，但本文不涉及这一点。 Spring 提供了多种调度方式。如 @Scheduled 注解，以及 Project Reactor 提供的 Flux::interval 方法，对于 Webflux 应用来说，该方法开箱即用，它还可以作为独立库用于任何 Java 项目。 此外，还有一些更专业的三方调度框架，如 Quartz Scheduler，但这不在本文范畴。 2、简单的聊天应用 在 上一篇文章 中，使用 WebSockets 构建了一个聊天应用。现在让我们用一项新功能来扩展它：聊天机器人。聊天机器人是向浏览器推送预定消息的服务器端组件。 2.1、Maven 依赖 先在 Maven 中添加必要依赖， pom.xml 如下： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> <dependency> <groupId>io.projectreactor</groupId> <artifactId>reactor-core</artifactId> </dependency> <dependency> <groupId>com.github.javafaker</groupId> <artifactId>javafaker</artifactId> <version>1.0.2</version> </dependency> <dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> </dependency> 2.2、JavaFaker 使用 JavaFaker 库生成机器人信息。该库通常用于生成测试数据。在这里，用于为聊天室添加一位名为 “Chuck Norris” 的访客。 代码如下： Faker faker = new Faker(); ChuckNorris chuckNorris = faker. https://springdoc.cn/spring-websockets-sendtouser/ Wed, 29 Nov 2023 16:10:00 +0800 https://springdoc.cn/spring-websockets-sendtouser/ 1、概览 本文将带你了解如何在 Spring WebSockets 中使用 @SendToUser 注解向特定 Session 或特定用户发送消息。 有关上述 Spring WebSockets 的介绍，请参阅 上一篇文章。 2、WebSocket 配置 首先，需要配置 Message Broker 和 WebSocket 应用端点： @Configuration @EnableWebSocketMessageBroker public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer { @Override public void configureMessageBroker(MessageBrokerRegistry config) { config.enableSimpleBroker("/topic/", "/queue/"); config.setApplicationDestinationPrefixes("/app"); } @Override public void registerStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint("/greeting"); } } 通过 @EnableWebSocketMessageBroker 注解，启用了在 WebSocket 上使用 STOMP（Streaming Text Oriented Messaging Protocol）的基于 Broker 的消息传递。需要强调的是，这个注解需要与 @Configuration 一起使用。 继承 AbstractWebSocketMessageBrokerConfigurer 并不是必须的，但这可以更容易地自定义导入的配置。 在第一个方法中，建立了一个简单的基于内存的 Message Broker，通过以 /topic 和 /queue 为前缀的目标将消息传回客户端。 https://springdoc.cn/websockets-spring/ Wed, 29 Nov 2023 15:36:50 +0800 https://springdoc.cn/websockets-spring/ 1、概览 本文将带你学习如何使用 Spring 4 中引入的 WebSocket 功能来实现一个简单的聊天应用。 WebSockets 是 Web 浏览器和服务器之间的一种双向、全双工、持久连接。一旦建立了 WebSocket 连接，该连接就会一直打开，直到客户端或服务器关闭该连接。 2、Maven 依赖 在 pom.xml 中添加所需的依赖： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-websocket</artifactId> <version>5.2.2.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-messaging</artifactId> <version>5.2.2.RELEASE</version> </dependency> 此外，还需要添加 Jackson 依赖，用于序列化/反序列化 JSON 格式的消息。 <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-core</artifactId> <version>2.10.2</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.10.2</version> </dependency> 3、启用 WebSocket 首先，在配置类上通过 @EnableWebSocketMessageBroker 注解来启用 WebSocket 功能。 配置类需要继承 AbstractWebSocketMessageBrokerConfigurer。 顾名思义，它能在 Message Broker 的支持下处理 WebSocket 消息： @Configuration @EnableWebSocketMessageBroker public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer { @Override public void configureMessageBroker(MessageBrokerRegistry config) { config. https://springdoc.cn/spring-resttemplate-json-list/ Wed, 29 Nov 2023 15:02:28 +0800 https://springdoc.cn/spring-resttemplate-json-list/ 1、概览 在 Spring Boot 应用中，一般使用 RestTemplate 来执行同步 HTTP 请求。数据通常以 JSON 的形式返回，而 RestTemplate 可以进行自动转换。 本文将带你了解，如何在 RestTemplate 中把响应的 JSON 数组转换为 Object 数组、POJO 数组和 POJO 集合。 2. JSON、POJO 和 Service 假设我们有一个端点 http://localhost:8080/users，它返回如下 JSON 格式的用户列表： [{ "id": 1, "name": "user1", }, { "id": 2, "name": "user2" }] 对应的 User 类如下： public class User { private int id; private String name; // get/set 方法省略 } 定义 Service 接口实现 UserConsumerServiceImpl，并注入 RestTemplate： public class UserConsumerServiceImpl implements UserConsumerService { private final RestTemplate restTemplate; public UserConsumerServiceImpl(RestTemplate restTemplate) { this. https://springdoc.cn/spring-bean-circular-dependencies/ Tue, 28 Nov 2023 18:34:25 +0800 https://springdoc.cn/spring-bean-circular-dependencies/ 1、背景 有好几次线上发布老应用时，遭遇代码启动报错，具体错误如下： Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'xxxManageFacadeImpl': Bean with name 'xxxManageFacadeImpl' has been injected into other beans [xxxProductMaintenceFacadeImpl] in its raw version as part of a circular reference, but has eventually been wrap means thff, for expped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesallowEageOfType' with the 'allowEagerInit' flag turned off, for example 咋眼一看，这不就是 Spring Bean 循环依赖报错吗？脑海立马闪过那些年为了进阿里面试时被死亡 N 连问的场景，那时我们都知道 Spring 已经支持 Bean 循环依赖，为啥我们的 Spring Boot 应用启动时还报这个错误？于是，带着这个问题重新温习下 Spring 如何解决 Bean 循环依赖。 https://springdoc.cn/spring-boot-customize-jackson-objectmapper/ Tue, 28 Nov 2023 16:47:13 +0800 https://springdoc.cn/spring-boot-customize-jackson-objectmapper/ 1、概览 Spring Boot 默认使用 Jackson ObjectMapper 实例来序列化和反序列化 JSON 格式的响应与请求。 本文将带你了解如何在 Spring Boot 中自定义 Jackson ObjectMapper 选项，以及配置序列化和反序列化选项的最常用方法。 2、默认配置 默认情况下，Spring Boot 禁用了以下功能： MapperFeature.DEFAULT_VIEW_INCLUSION DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES SerializationFeature.WRITE_DATES_AS_TIMESTAMPS 从一个简单的例子开始： 客户端向 /coffee?name=Lavazza 端点发送 GET 请求。 Controller 返回一个新的 Coffee 对象。 Spring 使用 ObjectMapper 将 POJO 序列化为 JSON。 使用 String 和 LocalDateTime 对象来演示自定义选项： public class Coffee { private String name; private String brand; private LocalDateTime date; // get / set 省略 } 定义一个简单的 REST Controller 来演示序列化： @GetMapping("/coffee") public Coffee getCoffee( @RequestParam(required = false) String brand, @RequestParam(required = false) String name) { return new Coffee() . https://springdoc.cn/spring-cloud-feign-integration-tests/ Tue, 28 Nov 2023 16:04:23 +0800 https://springdoc.cn/spring-cloud-feign-integration-tests/ 1、概览 本文将带你了解 Feign 客户端的集成测试。 首先创建一个基本的 Open Feign 客户端，并使用 WireMock 编写一个简单的集成测试。 之后，给客户端添加 Ribbon 配置，并为其构建一个集成测试。最后，配置一个 Eureka 测试容器，并测试此设置，以确保整个配置按预期工作。 2、Feign Client 要设置 Feign 客户端，首先要添加 Spring Cloud OpenFeign Maven 依赖： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> 然后，创建一个 Book 模型类： public class Book { private String title; private String author; } 最后，创建 Feign 客户端接口： @FeignClient(name = "books-service") public interface BooksClient { @RequestMapping("/books") List<Book> getBooks(); } 现在，我们有了一个从 REST 服务中获取 List<Book> 的 Feign 客户端。接下来，编写一些集成测试。 3、WireMock 3.1、设置 WireMock 服务器 要测试 BooksClient，需要一个提供 /books 端点的 mock 服务，客户端将调用该 mock 服务。为此，我们使用 WireMock。 https://springdoc.cn/spring-boot-repackage-vs-mvn-package/ Tue, 28 Nov 2023 15:27:48 +0800 https://springdoc.cn/spring-boot-repackage-vs-mvn-package/ 1、概览 Apache Maven 是一种广泛使用的项目依赖管理工具和项目构建工具。 Spring Boot 通过 Spring Boot Maven Plugin 在 Apache Maven 中提供了对 Spring Boot 的支持。 众所周知，在 Maven 中可以使用 mvn package 将应用打包为 JAR 或 WAR 包。不过，Spring Boot Maven 插件额外添加了一个 repackage goal，也可以在 mvn 命令中调用。 有时，这两个 mvn 命令会让人混淆。本文将带你了解 mvn package 和 spring-boot:repackage 之间的区别。 2、Spring Boot 应用示例 首先，创建一个简单的 Spring Boot 应用作为示例： @SpringBootApplication public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } } 创建一个简单的 REST 端点来验证应用是否正常运行： @RestController public class DemoRestController { @GetMapping(value = "/welcome") public ResponseEntity welcomeEndpoint() { return ResponseEntity. https://springdoc.cn/hibernate-proxy-to-real-entity-object/ Tue, 28 Nov 2023 14:46:21 +0800 https://springdoc.cn/hibernate-proxy-to-real-entity-object/ 1、概览 本文将带你了解 Hibernate 是在什么时候创建代理对象的，代理对象有啥用？以及如何把 Hibernate 的代理对象转换为真正的实体对象。 2、Hibernate 何时创建代理对象？ Hibernate 使用代理对象来实现懒加载。 有如下 PaymentReceipt 和 Payment 实体： @Entity public class PaymentReceipt { ... @OneToOne(fetch = FetchType.LAZY) private Payment payment; ... } @Entity @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) public abstract class Payment { ... @ManyToOne(fetch = FetchType.LAZY) protected WebUser webUser; ... } 加载这两个实体中的任何一个，都会导致 Hibernate 为关联字段使用 FetchType.LAZY 创建一个代理对象。 创建并运行集成测试： @Test public void givenPaymentReceipt_whenAccessingPayment_thenVerifyType() { PaymentReceipt paymentReceipt = entityManager.find(PaymentReceipt.class, 3L); Assert.assertTrue(paymentReceipt.getPayment() instanceof HibernateProxy); } 测试代码如上，加载了一个 PaymentReceipt，并验证了 payment 对象不是 CreditCardPayment 的实例，而是一个 HibernateProxy 对象。 https://springdoc.cn/jdbcclient-return-auto-key/ Mon, 27 Nov 2023 16:42:39 +0800 https://springdoc.cn/jdbcclient-return-auto-key/ JdbcClient 是 Spring 6.1 引入的一个 Jdbc 客户端工具类，提供了 Fluent 链式调用风格的查询和更新方法，支持 JDBC 风格的位置参数和 Spring 风格的命名参数绑定。 本文将带你了解，如何在使用 JdbcClient 执行 insert 操作时返回自增 ID。 关于 JdbcClient 更多详细的用法可以参阅 “Spring 6 JdbcClient API 指南” 和 “Spring Boot 中的新 JDBC 客户端： JdbcClient” 创建数据表 在本地 MYSQL 数据库 demo 中创建一张简单的 t_user 表，如下： CREATE TABLE `t_user` ( `id` int unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID', `create_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', `enabled` tinyint unsigned NOT NULL COMMENT '是否启用。0：禁用，1：启用', `name` varchar(50) COLLATE utf8mb4_general_ci NOT NULL COMMENT '名字', PRIMARY KEY (`id`), UNIQUE KEY `name` (`name`) ) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='用户'; 其中， id 列是自增列。 https://springdoc.cn/spring-rest-timeout/ Mon, 27 Nov 2023 15:20:23 +0800 https://springdoc.cn/spring-rest-timeout/ 1、概览 本文将带你了解给 Spring REST API 设置请求超时的几种方法。 当资源耗时过长时，请求超时机制可以避免糟糕的用户体验。当然也可以使用断路器模式（Circuit Breaker pattern）来实现，本文不细说。 2、@Transactional 超时 在数据库调用中实现请求超时的一种方法是利用 Spring 的 @Transactional 注解。它有一个 timeout 属性可以设置。该属性的默认值是 -1，相当于没有任何超时。 例如，假设将超时设置为 30 秒。如果注解方法的执行时间超过这个秒数，就会抛出异常。这对于回滚长时间运行的数据库查询可能很有用。 编写一个非常简单的 JPA Repository，它代表一个外部服务，该服务需要太长时间才能完成并导致超时。 这个 Repository 中有一个耗时的方法： public interface BookRepository extends JpaRepository<Book, String> { default int wasteTime() { Stopwatch watch = Stopwatch.createStarted(); // 延迟 2 秒 while (watch.elapsed(SECONDS) < 2) { int i = Integer.MIN_VALUE; while (i < Integer.MAX_VALUE) { i++; } } } } 如果在超时时间为 1 秒的事务中调用 wasteTime() 方法，超时时间将在方法执行完毕之前结束： https://springdoc.cn/spring-aop-get-advised-method-info/ Mon, 27 Nov 2023 12:49:45 +0800 https://springdoc.cn/spring-aop-get-advised-method-info/ 1、简介 本文将带你了解如何使用 Spring AOP Aspect 获取 Advise 方法的签名、参数、注解以及其他的额外信息。 2、Maven 依赖 首先，在 pom.xml 中添加 spring-boot-starter-aop Starter 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 3、创建 Pointcut 注解 创建一个 AccountOperation 注解，作为切面中的切点： @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface AccountOperation { String operation(); } 注意，切点（Pointcut）不一定非要使用注解定义。也可以使用 Spring AOP 提供的 Pointcut 定义语言定义其他 Pointcut 类型，如类中的某些方法、以某些前缀开头的方法等。 4、创建示例 Service 4.1、Account 类 创建一个 Account POJO，带有 accountNumber 和 balance 属性。 在 service 方法中使用它作为方法参数： public class Account { private String accountNumber; private double balance; // get/set toString方法省略 } 4. https://springdoc.cn/spring-webclient-json-list/ Mon, 27 Nov 2023 10:36:14 +0800 https://springdoc.cn/spring-webclient-json-list/ 1、概览 从 Spring 5 开始，可以使用 WebClient 以响应式、非阻塞的方式执行服务之间的 REST 通信。WebClient 是新的 WebFlux 框架的一部分，构建于 Project Reactor 之上。它使用 Fluent 风格的响应式 API，底层实现使用 HTTP 协议。 当发起 Web 请求时，数据通常会以 JSON 格式返回，本文将带你了解如何使用 WebClient 将响应的 JSON 数组转换为 Java Object 数组、POJO 数组和 POJO 集合。 2、依赖 在 pom.xml 中添加如下依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> </dependency> <dependency> <groupId>org.projectreactor</groupId> <artifactId>reactor-spring</artifactId> <version>1.0.1.RELEASE</version> </dependency> 3、JSON、POJO 和 Service 从端点 http://localhost:8080/readers 开始，它以 JSON 数组的形式返回读者最喜欢的书籍列表： [{ "id": 1, "name": "reader1", "favouriteBook": { "author": "Milan Kundera", "title": "The Unbearable Lightness of Being" } }, { "id": 2, "name": "reader2" "favouriteBook": { "author": "Douglas Adams", "title": "The Hitchhiker's Guide to the Galaxy" } }] 还需要相应的 Reader 和 Book 类来处理数据： https://springdoc.cn/spring-not-enough-variables-available/ Mon, 27 Nov 2023 10:04:27 +0800 https://springdoc.cn/spring-not-enough-variables-available/ 1、概览 本文将带你了解 Spring RestTemplate 抛出 IllegalArgumentException: Not enough variables available to expand 异常的原因以及解决办法。 2、原因 简而言之，当试图在 GET 请求参数中发送 JSON 数据时，通常会导致这个异常。 RestTemplate 提供了 getForObject 方法，通过在指定的 URL 上发出 GET 请求来获取表示对象。 出现异常的主要原因是 RestTemplate 将大括号中封装的 JSON 数据视为 URI 变量的占位符。 由于没有为预期的 URI 变量提供任何值，getForObject 方法就会抛出异常。 例如，尝试发送 {"name": "HP EliteBook"} 作为查询参数： String url = "http://products.api.com/get?key=a123456789z&criterion={\"name\":\"HP EliteBook\"}"; Product product = restTemplate.getForObject(url, Product.class); 将导致 RestTemplate 抛出异常： java.lang.IllegalArgumentException: Not enough variable values available to expand 'name' 3、示例应用 创建一个只有一个 GET 端点的基本 REST API 示例，来复现 RestTemplate 抛出 IllegalArgumentException 异常的情况。 https://springdoc.cn/java-rsa-codec/ Sun, 26 Nov 2023 18:01:26 +0800 https://springdoc.cn/java-rsa-codec/ RSA（Rivest-Shamir-Adleman）算法是一种非对称加密算法，广泛用于数据加密和数字签名领域。它是由 Ron Rivest、Adi Shamir 和 Leonard Adleman 于 1977 年共同提出的。 RSA 算法常用于如下场景： 公钥加密，私钥解密 私钥加密，公钥解密（不推荐） 私钥签名，公钥验签 生成密钥对 通过 Java java.security 包下的工具类可以生成 RSA 公钥和私钥。 package cn.springdoc.demo.test; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.interfaces.RSAPrivateKey; import java.security.interfaces.RSAPublicKey; import java.util.Base64; /** * @author springdoc.cn * 生成 RSA 密钥对 */ public class Main { public static void main(String[] args) throws Exception { // 初始化 Key 生成器，指定算法类型为 RSA KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); // 密钥长度为 2048 位 keyPairGenerator.initialize(2048); // 生成密钥对 KeyPair keyPair = keyPairGenerator. https://springdoc.cn/spring-prevent-xss/ Sun, 26 Nov 2023 16:54:20 +0800 https://springdoc.cn/spring-prevent-xss/ 1、概览 在构建 Spring Web 应用时，关注安全性非常重要。跨站脚本 （XSS） 是对 Web 安全威胁最大的攻击之一。 在 Spring 应用中，防止 XSS 攻击是一项挑战。Spring 提供了内置的帮助来实现全面的保护。 本文将带你了解如何通过 Spring Security 使用 X-XSS-Protection 和 Content-Security-Policy 机制来防止 XSS 攻击。 2、什么是跨站脚本（XSS）攻击？ 2.1、问题的定义 XSS 是一种常见的注入式攻击。在 XSS 中，攻击者试图在 Web 应用程序中执行恶意代码。他们通过 Web 浏览器或 HTTP 客户端工具（如 Postman）与应用交互。 XSS 攻击有两种类型： 反射性或非持久性 XSS 存储型或持久型 XSS 在反射型或非持久型 XSS 中，不受信任的用户数据被提交到 Web 应用，并立即在响应中返回，从而在页面中添加了不可信的内容。Web 浏览器会认为代码来自 Web 服务器并执行它。这可能会让黑客向你发送一个链接，当你点击该链接时，浏览器会从你使用的网站上获取你的私人数据，然后让你的浏览器将这些数据转发到黑客的服务器上。 在存储型或持久型 XSS 中，Web 服务器会存储攻击者的输入。随后，任何后来的访问者都可能执行该恶意代码。 2.2、防御攻击 防止 XSS 攻击的主要策略是清理用户输入。 在 Spring Web 应用中，用户的输入是 HTTP 请求。为防止攻击，应检查 HTTP 请求的内容，并删除可能可在服务器或浏览器中执行的任何内容。 对于通过 Web 浏览器访问的普通 Web 应用，可以使用 Spring Security 的内置功能（反射性 XSS）。 https://springdoc.cn/java-feign-file-upload/ Sun, 26 Nov 2023 16:26:12 +0800 https://springdoc.cn/java-feign-file-upload/ 1、概览 Feign 是微服务中通过 REST API 以声明方式与其他微服务通信的强大工具，本文将带你了解如何使用 Open Feign 上传文件。 2、先决条件 假设如下 RESTful Web 服务用于文件上传： POST http://localhost:8081/upload-file 该 Web 服务端点定义如下： @PostMapping(value = "/upload-file") public String handleFileUpload(@RequestPart(value = "file") MultipartFile file) { // 文件上传逻辑 } 3、依赖 为了支持文件上传的 application/x-www-form-urlencoded 和 multipart/form-data 编码类型，需要添加 feign-core、 feign-form 和 feign-form-spring 模块。 在 Maven 中添加以下依赖： <dependency> <groupId>io.github.openfeign</groupId> <artifactId>feign-core</artifactId> <version>10.12</version> </dependency> <dependency> <groupId>io.github.openfeign.form</groupId> <artifactId>feign-form</artifactId> <version>3.8.0</version> </dependency> <dependency> <groupId>io.github.openfeign.form</groupId> <artifactId>feign-form-spring</artifactId> <version>3.8.0</version> </dependency> 还可以直接使用 spring-cloud-starter-openfeign 依赖，它已经包含了 feign-core： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> <version>3.1.0</version> </dependency> 4、配置 在 main 类中添加 @EnableFeignClients： https://springdoc.cn/spring-component-annotation/ Sun, 26 Nov 2023 15:21:22 +0800 https://springdoc.cn/spring-component-annotation/ 1、概览 本文将带你全面了解 Spring @Component 注解及相关领域。 2、Spring ApplicationContext 在了解 @Component 之前，首先需要了解一下 Spring ApplicationContext。 Spring ApplicationContext 是 Spring 保存对象实例的地方，Spring 已确定这些实例将被自动管理和分发。这些实例被称为 Bean。 Spring 的一些主要功能包括 Bean 管理和依赖注入。 利用控制反转（Inversion of Control），Spring 可以从应用中收集 Bean 实例，并在适当的时候使用它们。可以在 Spring 中定义 Bean 依赖，而无需处理这些对象的设置和实例化。 使用 @Autowired 等注解将 Spring 管理的 Bean 注入应用的能力是在 Spring 中创建功能强大且可扩展代码的驱动力。 那么，如何让 Spring 来管理的 Bean 呢？可以利用 Spring 的自动 Bean 检测功能，通过在类中使用元注解（Stereotype Annotation）来实现。 3、@Component @Component 是一个注解，它允许 Spring 自动检测自定义 Bean。 换句话说，无需编写任何明确的代码，Spring 就能做到： 扫描应用，查找注解为 @Component 的类 将它们实例化，并注入任何指定的依赖 在需要的地方注入 不过，大多数时候应该使用更专业的元（Stereotype）注解来实现这一功能。 3.1、Spring 元注解 Spring 提供了一些专门的元注解：@Controller、@Service 和 @Repository。它们都提供了与 @Component 相同的功能。 https://springdoc.cn/spring-no-converter-found/ Sun, 26 Nov 2023 10:30:04 +0800 https://springdoc.cn/spring-no-converter-found/ 1、概览 本文将带你了解 Spring 中出现 HttpMessageNotWritableException: "No converter found for return value of type" 异常的原因以及解决办法。 2、原因 通常，当 Spring 无法获取返回对象的属性时，就会出现这种异常。 导致这种异常的最典型原因通常是返回对象的属性没有任何 public getter 方法。 默认情况下，Spring Boot 依赖于 Jackson 库来完成序列化/反序列化请求和响应对象的所有工作。 因此，导致异常的另一个常见原因可能是 缺少或使用了错误的 Jackson 依赖。 简而言之，这种异常情况的一般准则是检查是否存在以下情况： 默认构造器 Getter 方法 Jackson 依赖 注意，异常类型 已从 java.lang.IllegalArgumentException 变为 org.springframework.http.converter.HttpMessageNotWritableException。 3、实例 现在，来看看一个会产生 org.springframework.http.converter.HttpMessageNotWritableException: "No converter found for return value of type" 异常的示例 使用 Spring Boot 构建一个基本的 REST API。 首先，创建 Student Model 类，并假装忘记生成 Getter 方法： public class Student { private int id; private String firstName; private String lastName; private String grade; public Student() { } public Student(int id, String firstName, String lastName, String grade) { this. https://springdoc.cn/rest-api-jax-rs-vs-spring/ Sun, 26 Nov 2023 10:15:07 +0800 https://springdoc.cn/rest-api-jax-rs-vs-spring/ 1、概览 本文将带你了解 JAX-RS 和 Spring MVC 在 REST API 开发方面的区别。 2、Jakarta RESTful Web 服务 要成为 Jakarta EE 世界的一部分，一项功能必须具备规范、兼容的实现和 TCK（技术兼容套件）。JAX-RS 就是一套用于构建 REST 服务的规范。其最著名的参考实现是 RESTEasy 和 Jersey。 现在，通过实现一个简单的 Controller 来熟悉一下 Jersey： @Path("/hello") public class HelloController { @GET @Path("/{name}") @Produces(MediaType.TEXT_PLAIN) public Response hello(@PathParam("name") String name) { return Response.ok("Hello, " + name).build(); } } 上面的代码中，端点返回一个简单的 “text/plain” 响应，这是由 @Produces 注解指定的。具体来说，暴露了一个名为 hello 的 HTTP 资源，它接受一个名为 name 的参数，使用了两个 @Path 注解进行路径的定义。还使用 @GET 注解指定它是一个 GET 请求。 3、使用 Spring MVC 实现 REST Spring MVC 是 Spring Framework 的一个模块，用于创建 Web 应用程序。它为 Spring Framework 添加了 REST 功能。 https://springdoc.cn/spring-entityscan-vs-componentscan/ Sun, 26 Nov 2023 09:51:08 +0800 https://springdoc.cn/spring-entityscan-vs-componentscan/ 1、概览 在 Spring 应用中，我们通常使用 @EntityScan 来指定实体类所在的包，使用 @ComponentScan 来指定 Bean 组件所在的包。 组件是带有 @Controller、@Service、@Repository、@Component、@Bean 等注解的类。实体则是带有 @Entity 注解的类。 本文将带你了解 @EntityScan 和 @ComponentScan 注解在 Spring 中的用法和区别。 2、@EntityScan 注解 在 Spring 中，有 2 种方式放置 @Entity 实体类： 在 main 包或者其子包下 在完全不同的 root 包中 在第一种情况下，可以使用 @EnableAutoConfiguration 来启用 Spring 自动配置 Application Context。 在第二种情况下，需要用 @EntityScan 来告诉 Spring 实体所在的包，如下。 @Configuration @EntityScan("com.baeldung.demopackage") public class EntityScanDemo { // ... } 注意，使用 @EntityScan 会禁用 Spring Boot 对实体的自动扫描配置。 3、@ComponentScan 注解 与 @EntityScan 和实体类似，如果我们希望 Spring 只使用一组特定的 Bean 类，可以使用 @ComponentScan 注解。 https://springdoc.cn/spring-boot-3-2-with-virtual-threads-and-graalvm-out-of-the-box/ Sun, 26 Nov 2023 09:13:56 +0800 https://springdoc.cn/spring-boot-3-2-with-virtual-threads-and-graalvm-out-of-the-box/ Spring Boot 3.2 前几天 发布 了，让我们用 Java 21、GraalVM 和 Virtual Threads（虚拟线程）来快速体验一下。 Spring Boot 3.2 支持： Java 21 虚拟线程 原生镜像（自 2022 年 11 月 Spring Boot 3.0 发布以来，Spring Boot 已在生产中支持 GraalVM 原生镜像） Java 21 2023 年 9 月 19 日 Java 21 发布。 正如宣布的那样，Java 21 在性能、稳定性和安全性方面进行了数千项改进，包括平台增强功能，这有助于开发人员提高生产力，推动整个组织的创新和发展。 Project Loom 其中一个比较重要的更新是虚拟线程（Virtual Thread），这是 Project Loom 提供的功能。具体细节这里就不多说了，你可以参考官方的 JEP：https://openjdk.org/jeps/444。 GraalVM 和 Native image GraalVM 是一款高性能 JDK，可使用另一种即时（JIT）编译器提高 Java 和基于 JVM 的应用程序的性能。 原生镜像（Native image）是一种将 Java 代码提前编译成独立可执行文件（称为原生镜像）的技术。该可执行文件包括应用程序类、其依赖项中的类、运行时库类以及 JDK 中静态链接的本地代码。 https://springdoc.cn/restclient-upload-json-file-form/ Sat, 25 Nov 2023 17:01:23 +0800 https://springdoc.cn/restclient-upload-json-file-form/ 前几天 Spring Boot 3.2 正式 发布 了，本次发布带来了一个新的 HTTP 客户端：RestClient，它提供了 Fluent 风格的 API，比起 RestTemplate 来说更加优雅。 关于 RestClient 的更多信息，你可以参考如下文章： Spring RestClient 教程 Spring 6.1的新特性：RestClient 本文将会带你了解如何使用 RestClient 同时上传文件、JSON 和表单数据。 关于如何使用 RestTemplate 进行文件上传，你可以参考 “RestTemplate 上传文件” 和 “在 Spring Boot 应用中同时上传文件、JSON和表单数据”。 本文使用的 Spring Boot 版本为 3.2.0。 创建 Controller 首先在 Spring Boot 应用中，创建一个处理 multipart/form-data 文件上传请求的 Controller。 package cn.springdoc.demo.web.controller; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.PostMapping; import org. https://springdoc.cn/spring-security-oauth-auth-server/ Sat, 25 Nov 2023 14:40:07 +0800 https://springdoc.cn/spring-security-oauth-auth-server/ 1、简介 OAuth 是一种描述授权过程的开放标准。它可用于授权用户访问 API。例如，REST API 可以限制只有具有适当角色的注册用户才能访问。 OAuth 授权服务器负责认证用户身份，并签发包含用户数据和适当访问策略的访问令牌（Access Token）。 本将带你了解如何使用 Spring Security OAuth 授权服务器 实现一个简单的 OAuth 应用。 我们要创建一个 CS 应用，通过 REST API 获取资源服务器上的文章列表。客户端服务和服务器服务都需要 OAuth 身份认证。 2、授权服务器实现 先来看看 OAuth 授权服务器的配置。它作为文章资源和客户端服务器的身份认证源。 2.1、依赖 首先，在 pom.xml 中添加如下依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.5.4</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> <version>2.5.4</version> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-oauth2-authorization-server</artifactId> <version>0.2.0</version> </dependency> 2.2、配置 在 application.yml 文件中，设置 server.port 属性来配置认证服务器的运行端口： server: port: 9000 然后，就可以开始配置 Spring Bean 了。首先，需要一个 @Configuration 类，在该类中创建一些 OAuth 特有的 Bean。 第一个是客户端服务的 Repository。在本例中，使用 RegisteredClient Builder 类创建一个客户端： https://springdoc.cn/spring-boot-get-all-endpoints/ Sat, 25 Nov 2023 13:32:55 +0800 https://springdoc.cn/spring-boot-get-all-endpoints/ 1、概览 本文将带你了解如何获取 Spring Boot 应用中的所有 REST 端点。 2、映射端点 在 Spring Boot 应用中，通过在 Controller 类中使用 @RequestMapping 注解来暴露 REST API 端点。要获取这些端点，有三种选择：事件监听器、Spring Boot Actuator 或 SpringDoc。 3、事件监听器 在 Controller 中使用 @RestController 和 @RequestMapping 创建 REST API 服务。这些类在 Spring Application Context 中注册为 Spring Bean。因此，当 Application Context 在启动时准备就绪，就可以使用事件监听器获取端点。定义监听器有两种方法。可以实现 ApplicationListener 接口，或者使用 @EventListener 注解。 3.1、ApplicationListener 接口 在实现 ApplicationListener 时，必须定义 onApplicationEvent() 方法： @Override public void onApplicationEvent(ContextRefreshedEvent event) { ApplicationContext applicationContext = event.getApplicationContext(); RequestMappingHandlerMapping requestMappingHandlerMapping = applicationContext .getBean("requestMappingHandlerMapping", RequestMappingHandlerMapping.class); Map<RequestMappingInfo, HandlerMethod> map = requestMappingHandlerMapping . https://springdoc.cn/spring-boot-3-2-0-available-now/ Fri, 24 Nov 2023 14:45:02 +0800 https://springdoc.cn/spring-boot-3-2-0-available-now/ 该版本增加了大量新功能和改进。有关完整的 升级说明 以及 新的和值得注意 的功能，请参阅 发布说明。 3.2 中的新特性 3.2 版的亮点包括： 支持虚拟线程（Virtual Threads） 初步支持 JVM Checkpoint Restore（Project CRaC） SSL Bundle 重新加载 大量可观测性的改进 支持 RestClient 支持 JdbcClient 支持 Jetty 12 为 Apache Pulsar 提供 Spring 支持 为 Kafka 和 RabbitMQ 提供 SSL Bundle 支持 重新处理了嵌套 Jar 文件的处理方式 改进 Docker Image 构建 依赖升级 Spring Boot 3.2 迁移到了多个 Spring 项目的新版本，还尽可能升级到了其他第三方库的最新稳定版本。详情请参见 发布说明。 其他变化 发行说明 中还记录了许多其他更改和改进。还可以找到计划在未来删除的废弃类和方法列表。 Ref：https://spring.io/blog/2023/11/23/spring-boot-3-2-0-available-now https://springdoc.cn/spring-not-eligible-for-auto-proxying/ Fri, 24 Nov 2023 13:41:14 +0800 https://springdoc.cn/spring-not-eligible-for-auto-proxying/ 1、概览 本文将带你了解出现 “not eligible for auto-proxying” 警告的原因以及如何修复它。 2、“not eligible for auto proxying” 的原因 2.1、配置示例 首先，创建一个自定义 RandomInt 注解，使用它来注解应该插入指定范围内的随机整数的字段。 @Retention(RetentionPolicy.RUNTIME) public @interface RandomInt { int min(); int max(); } 其次，创建一个简单的 Spring 组件 DataCache 类。将一个可能被使用的随机 Group 分配给缓存，例如用于支持分片。为了实现这一点，使用自定义的注解来注解该字段： @Component public class DataCache { @RandomInt(min = 2, max = 10) private int group; private String name; } 现在，来看看 RandomIntGenerator 类。它是一个 Spring 组件，用于在 RandomInt 注解注解的字段中插入随机 int 值： @Component public class RandomIntGenerator { private Random random = new Random(); private DataCache dataCache; public RandomIntGenerator(DataCache dataCache) { this. https://springdoc.cn/spring-boot-actuator-enable-endpoints/ Fri, 24 Nov 2023 12:54:16 +0800 https://springdoc.cn/spring-boot-actuator-enable-endpoints/ 1、概览 本文将带你了解如何通过 properties 文件控制 Spring Boot Actuator 端点的状态，以及如何保证端点的安全。 2、设置 为了使用 Actuator，需要在 Maven 配置中包含 spring-boot-starter-actuator： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> <version>3.1.2</version> </dependency> 此外，从 Spring Boot 2.0 开始，如果想通过 HTTP 暴露端点，就需要包含 Web Starter： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>3.1.2</version> </dependency> 3、启用和暴露端点 默认情况下，除 /shutdown 之外的所有端点都已启用，只有 /health 和 /info 被暴露。即使为应用配置了不同的 Root Context，也能在 /actuator 中找到所有端点。 这意味着，一旦在 Maven 配置中添加了相应的 Stater，就可以访问 http://localhost:8080/actuator/health 和 http://localhost:8080/actuator/info 上的 /health 和 /info 端点。 访问 http://localhost:8080/actuator，查看可用端点列表，因为 Actuator 端点已启用 HATEOS。所以，应该能看到 /health 和 /info。 {"_links":{"self":{"href":"http://localhost:8080/actuator","templated":false}, "health":{"href":"http://localhost:8080/actuator/health","templated":false}, "info":{"href":"http://localhost:8080/actuator/info","templated":false}}} 3.1、暴露所有端点 现在，修改 application. https://springdoc.cn/spring-boot-and-jsp/ Fri, 24 Nov 2023 10:41:18 +0800 https://springdoc.cn/spring-boot-and-jsp/ 1、概览 在构建 Java Web 应用时，可以使用 Java Server Pages（JSP）作为 HTML 页面模板。 Spring Boot 是一个流行的框架，可以用它来快速开发 Java Web 应用。 但是，在 Spring Boot 中使用 JSP 有一定的局限性，应该考虑用 Thymeleaf 或 FreeMarker 来替代 JSP。 2、Maven 依赖 首先来看看在 Spring Boot 中使用 JSP 需要哪些依赖。 2.1、作为独立应用运行 首先，添加 spring-boot-starter-web 依赖。 该依赖提供了使用 Spring Boot 和默认的嵌入式 Tomcat Servlet 容器来运行 Web 应用的所有核心依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.4.4</version> </dependency> 注意，使用 Undertow 作为嵌入式 Servlet 容器使用时不支持 JSP。 接下来，需要添加 tomcat-embed-jasper 依赖，以便应用能够编译和渲染 JSP 页面： <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <version>9.0.44</version> </dependency> 虽然可以手动提供上述两个依赖，但通常最好让 Spring Boot 管理这些依赖的版本，而我们只需管理 Spring Boot 版本即可。 https://springdoc.cn/spring-setting-bean-null/ Fri, 24 Nov 2023 09:31:01 +0800 https://springdoc.cn/spring-setting-bean-null/ 1、概览 本文将带你了解如何把 Spring Context 中的 Bean 设置为 null。在某些情况下，这可能很有用。例如，在测试时不想提供 Mock 对象。以及，在使用一些可选功能时，可能希望避免创建实现，并直接传递 null。 2、组件设置 有几种方法可以将 Bean 设置为 null，具体取决于 Context 的配置方式，本文主要考虑 XML、注解和 Java 配置的方式。 使用一个简单的设置，包含两个类： @Component public class MainComponent { private SubComponent subComponent; public MainComponent(final SubComponent subComponent) { this.subComponent = subComponent; } public SubComponent getSubComponent() { return subComponent; } public void setSubComponent(final SubComponent subComponent) { this.subComponent = subComponent; } } 本例将演示如何在 Spring Context 中将 SubComponent 设置为 null： @Component public class SubComponent {} 3、在 XML 配置中使用占位符 在 XML 配置中，可以使用一个特殊的占位符来标识 null 值： https://springdoc.cn/spring-boot-json-long-2-string/ Thu, 23 Nov 2023 15:56:12 +0800 https://springdoc.cn/spring-boot-json-long-2-string/ 什么是精度丢失？ Java 中长整形 Long （64位）的取值范围是：-9223372036854775808 - 9223372036854775807。 在这种情况下，由于 JavaScript 的 Number 类型是 64 位浮点数，它无法精确表示超过 53 位的整数。因此，当将 Java Long 类型的值传递给 JavaScript 时，可能会发生精度丢失。 你可以在浏览器控制台运行如下代码，更直观地感受 “精度丢失” 的问题。 let val = 9223372036854775807; console.log(val); //9223372036854776000 输出的值丢失了精度 如果我们在业务中使用 Long 作为数据类型，那么就必须要考虑浏览器客户端中 Js 存在精度丢失的问题。解决这个问题最简单的办法就是 把 Java 的 Long 值，序列化为字符串传递。 Jackson 的注解支持 Spring Boot 默认使用 Jackson 作为 JSON 的序列化、反序列化框架。Jackson 提供了 @JsonSerialize 注解，该注解的 using 属性可以指定一个 JsonSerializer 的实现类，用于自定义字段的序列化方式。 Jackson 已经预定义了一个实现 ToStringSerializer，用于把指定的字段序列化为字符串。 定义一个简单的 User 对象： package cn.springdoc.demo.model; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.fasterxml.jackson.databind.ser.std.ToStringSerializer; public class User { // 把 Long 类型的 id 序列化为 字符串 @JsonSerialize(using = ToStringSerializer. https://springdoc.cn/spring-tls-setup/ Thu, 23 Nov 2023 15:21:11 +0800 https://springdoc.cn/spring-tls-setup/ 1、概览 安全通信在现代应用中发挥着重要作用。客户端和服务器之间通过普通 HTTP 进行的通信并不安全。对于生产级的应用，应该在应用中通过 TLS（传输层安全）协议启用 HTTPS。 本文将带你了解如何在 Spring Boot 应用中启用 TLS。 2、TLS 协议 TLS 为客户端和服务器之间的数据传输提供保护，是 HTTPS 协议的关键组成部分。安全套接字层（SSL）和 TLS 经常被互换使用，但两者并不相同。事实上，TLS 是 SSL 的继承者。TLS 可以单向或双向实现。 2.1、单向 TLS 在单向 TLS 中，只有客户端对服务器进行验证，以确保从受信任的服务器接收数据。为实现单向 TLS，服务器会与客户端共享其公共证书。 2.2、双向 TLS 在双向 TLS 或相互 TLS（mTLS）中，客户端和服务器都要相互验证，以确保通信双方都是可信的。在实现 mTLS 时，双方要共享各自的公开证书。 3、Spring Boot 配置 TLS 3.1、生成密钥对 要启用 TLS，需要创建一对公钥/私钥。为此，可以使用 keytool 命令行工具，它默认 随 Java 发行版一起提供。 使用 keytool 生成一对密钥，并将其存储到 keystore.p12 文件中： keytool -genkeypair -alias baeldung -keyalg RSA -keysize 4096 \ -validity 3650 -dname "CN=localhost" -keypass changeit -keystore keystore. https://springdoc.cn/java-sentinel-intro/ Thu, 23 Nov 2023 14:42:51 +0800 https://springdoc.cn/java-sentinel-intro/ 1、概览 Sentinel，哨兵。顾名思义，它是微服务的强大守护者。它提供流量控制、并发限制、熔断和自适应系统保护等功能，以确保微服务的可靠性。它是一个开源组件，由阿里巴巴集团积极维护。此外，它还是 Spring Cloud Circuit Breaker 的官方组成部分。 本文将带你了解 Alibaba Sentinel 的核心功能，包括的流量控制、熔断器和自适应系统保护，以及它的注解支持和监控仪表盘。 2、功能 2.1、流量控制 Sentinel 控制随机传入请求的速度，以避免微服务超载。这可确保服务不会因流量激增而瘫痪。它支持各种流量整形策略。当每秒查询次数（QPS）过高时，这些策略会自动将流量调整为适当的形状。 这些流量整形策略包括： 直接拒绝模式（Direct Rejection Mode）- 当每秒请求数超过设定阈值时，它会自动拒绝后续的请求。 慢启动预热模式（Slow Start Warm-Up Mode） - 如果有突发的流量激增，此模式确保请求计数逐渐增加，直到达到上限为止。 2.2、熔断和降级 当一个服务同步调用另一个服务时，另一个服务有可能因某种原因宕机。在这种情况下，线程会被阻塞，因为它们一直在等待另一个服务的响应。这会导致资源耗尽，调用方服务也将无法处理更多请求。这就是所谓的级联效应，可能会导致整个微服务架构崩溃。 为了防止出现这种情况，引入了熔断器（Circuit Breaker）。它会立即阻止对其他服务的所有后续调用。在超时时间过后，一些请求会通过。如果请求成功，熔断器就会恢复正常流量。否则，超时时间将重新开始计时。 Sentinel 利用最大并发限制原理实现熔断。它通过限制并发线程的数量来减少不稳定资源的影响。 Sentinel 也会将不稳定的资源降级。当资源的响应时间过长时，对资源的所有调用都将在指定的时间窗口内被拒绝。这样可以防止调用变得非常缓慢，从而导致连锁效应。 2.3、自适应系统保护 Sentinel 会在系统负载过高时保护服务器。它使用 load1（系统负载）作为启动流量控制的指标。在以下情况下，请求将被阻止： 当前系统负载（load1） > 临界值（highestSystemLoad）。 当前并发请求（线程数） > 预计容量（最短响应时间 * 最大 QPS） 3、用法 3.1、添加 Maven 依赖 在 pom.xml 中添加 sentinel-core 依赖： <dependency> <groupId>com.alibaba.csp</groupId> <artifactId>sentinel-core</artifactId> <version>1.8.0</version> </dependency> 3.2、定义资源 使用 Sentinel API 在 try-catch 块中定义资源和相应的业务逻辑： try (Entry entry = SphU. https://springdoc.cn/spring-bean-names/ Thu, 23 Nov 2023 14:06:50 +0800 https://springdoc.cn/spring-bean-names/ 1、概览 当有多个相同类型的实现时，需要对 Spring Bean 进行不同的命名。这是因为如果 Bean 没有唯一的名称，Spring 在注入 Bean 时会出现歧义。 通过控制 Bean 的命名，可以告诉 Spring 我们想将哪个 Bean 注入到目标对象中。 本文将带你了解 Spring Bean 命名策略，以及如何为同一类型的 Bean 赋予多个名称。 2、默认 Bean 命名策略 Spring 为创建 Bean 提供了多种注解，可以在不同的级别使用。例如，可以在 Bean 类上放置一些注解，在创建 Bean 的方法上放置另一些注解。 首先，来看看 Spring 的默认命名策略。当只指定注解而不指定任何值时，Spring 是如何命名 Bean 的？ 2.1、类级注解 首先从在类级别使用的注解的默认命名策略开始。Spring 会使用类名为 Bean 命名，并将第一个字母转换为小写。 举个例子： @Service public class LoggingService { } 如上，Spring 为 LoggingService 类创建了一个 Bean，并使用 loggingService 名称进行了注册。 这种默认的命名策略适用于所有用于创建 Spring Bean 的类级别注解，例如 @Component、@Service 和 @Controller。 2.2、方法级注解 Spring 提供了 @Bean 和 @Qualifier 等注解，可用于创建 Bean 的方法。 https://springdoc.cn/spring-boot-implement-read-write-separation/ Thu, 23 Nov 2023 13:03:14 +0800 https://springdoc.cn/spring-boot-implement-read-write-separation/ 一、读写分离介绍 当使用Spring Boot开发数据库应用时，读写分离是一种常见的优化策略。读写分离将读操作和写操作分别分配给不同的数据库实例，以提高系统的吞吐量和性能。 读写分离实现主要是通过动态数据源功能实现的，动态数据源是一种通过在运行时动态切换数据库连接的机制。它允许应用程序根据不同的条件或配置选择不同的数据源，以实现更灵活和可扩展的数据库访问。 二、实现读写分离 - 基础 1、配置主数据库和从数据库的连接信息 # 主库配置 spring.datasource.master.jdbc-url=jdbc:mysql://ip:port/master?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false spring.datasource.master.username=master spring.datasource.master.password=123456 spring.datasource.master.driver-class-name=com.mysql.jdbc.Driver # 从库配置 spring.datasource.slave.jdbc-url=jdbc:mysql://ip:port/slave?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false spring.datasource.slave.username=slave spring.datasource.slave.password=123456 spring.datasource.slave.driver-class-name=com.mysql.jdbc.Driver 2、创建主数据库和从数据库的数据源配置类 通过不同的条件限制和配置文件前缀可以完成不同数据源的创建工作，不止是主从也可以是多个不同的数据库。 主库数据源配置： @Configuration @ConditionalOnProperty("spring.datasource.master.jdbc-url") public class MasterDataSourceConfiguration { @Bean("masterDataSource") @ConfigurationProperties(prefix = "spring.datasource.master") public DataSource masterDataSource() { return DataSourceBuilder.create().build(); } } 从库数据源配置： @Configuration @ConditionalOnProperty("spring.datasource.slave.jdbc-url") public class SlaveDataSourceConfiguration { @Bean("slaveDataSource") @ConfigurationProperties(prefix = "spring.datasource.slave") public DataSource slaveDataSource() { return DataSourceBuilder.create().build(); } } 3、创建主从数据源枚举 public enum DataSourceTypeEnum { /** * 主库 */ MASTER, /** * 从库 */ SLAVE, ; } 4、创建动态路由数据源 这儿做了一个开关，可以控制读写分离的开启和关闭工作，可以将操作全部切换到主库进行。然后根据上下文中的数据源类型来返回不同的数据源类型枚举。 https://springdoc.cn/spring-thymeleaf-error-messages/ Thu, 23 Nov 2023 11:19:26 +0800 https://springdoc.cn/spring-thymeleaf-error-messages/ 1、概览 本文将带你了解如何在 Spring 应用中使用 Thymeleaf 模板来渲染错误信息。 我们会通过一个简单的 Spring Boot 项目来进行演示，该项目是一个 “用户注册” 应用，需要验证客户端传递的各个字段，还要处理全局错误。 2、Spring Boot 应用示例 创建一个简单的 Spring Boot 用户注册应用，需要一个 Controller、一个 Repository 和一个 Entity。 2.1、Maven 依赖 添加所有需要的 Spring Boot Starter：Web Mvc、Hibernate Validation、 Thymeleaf 和 JPA。 此外，还需要一个 H2 内存数据库依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validation</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>runtime</scope> <version>1.4.200</version> </dependency> 2.2、实体 User 实体如下： @Entity public class User { @Id @GeneratedValue(strategy = GenerationType. https://springdoc.cn/spring-beans-integration-test-override/ Thu, 23 Nov 2023 09:45:47 +0800 https://springdoc.cn/spring-beans-integration-test-override/ 1、概览 在 Spring 集成测试中，我们可能想要覆盖应用的一些 Bean。通常，可以使用专门为测试定义的 Spring Bean 来实现。然而，在 Spring Context 中提供多个具有相同名称的 Bean，可能会遇到 BeanDefinitionOverrideException 异常。 本文将带你了解如何在 Spring Boot 应用中 Mock 或 Stub 集成测试的 Bean，同时避免 BeanDefinitionOverrideException。 2、在测试中使用 Mock 或 Stub 在深入了解细节之前，应该了解如何在测试中使用 Mock 或 Stub。这是一种强大的技术，可以确保应用不会出现错误。 也可以在 Spring 中采用这种方法。不过，只有在使用 Spring Boot 时才能直接模拟集成测试 Bean。 或者，也可以使用测试配置来 Stub 或 Mock bean。 3、Spring Boot 应用示例 创建一个简单的 Spring Boot 应用，包含了一个 Controller、Service 和一个 Configuration 类。 @RestController public class Endpoint { private final Service service; public Endpoint(Service service) { this.service = service; } @GetMapping("/hello") public String helloWorldEndpoint() { return service. https://springdoc.cn/kafka-manage-consumer-groups/ Thu, 23 Nov 2023 08:50:24 +0800 https://springdoc.cn/kafka-manage-consumer-groups/ 1、简介 消费者组允许多个消费者从同一 Topic 消费数据，有助于创建更具可扩展性的 Kafka 应用。 本文将带你了解消费者组以及它们如何在其消费者之间重新平衡分区（Rebalance Partition）。 2、消费者组是什么？ 消费者组是一组与一个或多个 Topic 相关联的唯一消费者。每个消费者可以从 0 个、1 个或多个分区中消费数据。此外，每个分区在给定时间内只能分配给一个消费者。分区分配会随着群成员的变化而变化。这就是所谓的组重新平衡（Group Rebalancing）。 消费者分组是 Kafka 应用的重要组成部分。它允许将类似的消费者分组，使他们可以并行地从一个分区 Topic 中消费数据。因此，它提高了 Kafka 应用的性能和可扩展性。 2.1、Group Coordinator 和 Group Leader 当实例化消费者组时，Kafka 也会创建 Group Coordinator（组协调器）。Group Coordinator 会定期接收来自消费者的请求，这些请求被称为 “心跳”。如果某个消费者停止发送心跳，Coordinator 就会认为该消费者要么已经离开了组，要么已经崩溃。这就是分区重新平衡（Partition Rebalance）的一个可能触发因素。 第一个向 Group Coordinator 提出加入 Group 请求的消费者成为 Group Leader。当因任何原因发生重新平衡（Rebalance）时，Leader 会从 Group Coordinator 处收到一份 Group 成员列表。然后，Leader 会使用 partition.assignment.strategy 配置中的自定义策略，在列表中的消费者之间重新分配分区。 2.2、提交的偏移量（Committed Offset） Kafka 使用提交的偏移量（Committed Offset）来跟踪从 Topic 读取的最后位置。提交的偏移量是消费者确认成功处理的 Topic 位置。换句话说，它是自身和其他消费者在后续轮次中读取事件的起始点。 Kafka 将所有分区提交的偏移量（committed offsets）存储在名为 __consumer_offsets 的内部 Topic 中。可以放心地信任它的信息，因为对于副本（Replicated） Broker 来说，Topic 是持久（durable）和容错的（fault-tolerant）。 https://springdoc.cn/what-s-new-in-spring-framework-6-x/ Sat, 18 Nov 2023 09:15:04 +0800 https://springdoc.cn/what-s-new-in-spring-framework-6-x/ Spring Framework 6.1 中的新变化 核心容器 总体上 与虚拟线程和 JDK 21 兼容。 虚拟线程的配置选项：专用的 VirtualThreadTaskExecutor 和 SimpleAsyncTaskExecutor 上的虚拟线程模式，以及具有新线程每个任务策略和虚拟线程模式的类似的 SimpleAsyncTaskScheduler。 与 Project CRaC（JVM 检查点恢复）的生命周期集成（请参阅 相关文档)），包括 -Dspring.context.checkpoint=onRefresh 选项。 为 ThreadPoolTaskExecutor 和 ThreadPoolTaskScheduler 以及 SimpleAsyncTaskScheduler 集成了生命周期 暂停/恢复功能 和 并行优雅停机 功能。 可使用 -Dspring.context.exit=onRefresh 选项进行 AppCDS 训练运行，这是主要的用例；请参阅 31595。 可达性元数据贡献改进，为即将到来的 GraalVM 变动做准备：缺失的可达性元数据将很快报告为运行时异常，以获得更好的开发人员体验。参见 31213。 异步/响应式销毁方法（如 R2DBC ConnectionFactory）；参见 26691。 异步/响应式 Cacheable 方法，包括缓存接口和 CaffeineCacheManager 中的相应支持；参见 17559 和 17920。 响应式 @Scheduled 方法（包括 Kotlin 正则表达式）；参见 22924。 为每个 @Scheduled 方法选择特定目标调度器；见 20818。 用于一次性任务（仅有初始延迟）的 @Scheduled 方法；见 31211。 @Scheduled 方法的可观测性；见 29883。 Spring 不会为 @Async 或 @EventListener 注解的方法生成开箱即用的观测结果，但会帮助你为这些方法的执行传播上下文（例如带有当前 trace id 的 MDC 日志）。请参见新的 ContextPropagatingTaskDecorator、相关参考文档部分 和 issue 31130。 Validator 工厂方法，用于编程式 validator 实现；请参阅 29890。 Validator. https://springdoc.cn/kafka-tracing-with-spring-boot-and-open-telemetry/ Thu, 16 Nov 2023 12:10:16 +0800 https://springdoc.cn/kafka-tracing-with-spring-boot-and-open-telemetry/ 本文将带你了解如何使用 Spring Boot 和 Open Telemetry 为 Kafka 生产者和消费者配置追踪功能。我们会使用 Micrometer 库发送追踪信息，并使用Jaeger来存储和可视化这些数据。Spring Kafka内置了与 Micrometer 的集成，用于 KafkaTemplate 和监听容器。本文还会介绍何配置 Spring Kafka observability （可观察性），以在追踪中添加自定义标签（Tag）。 源码 你可以在 GitHub 上找到完整的源码。Clone 项目后，进入 kafka 目录，按照说明进行操作即可。 依赖 添加如下依赖，其中 Spring Boot Starter 和 Spring Kafka 用于发送或接收消息，Spring Boot Actuator 和 Micrometer Tracing Open Telemetry 桥接器用于自动生成与每条消息相关的追踪，最后是 opentelemetry-exporter-otlp，用于将追踪导出到应用外。 对于本文中的两个示例 Spring Boot 应用，依赖都是相同的。 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> </dependency> <dependency> <groupId>io.micrometer</groupId> <artifactId>micrometer-tracing-bridge-otel</artifactId> </dependency> <dependency> <groupId>io. https://springdoc.cn/spring-boot-enabled-gzip-compression/ Wed, 15 Nov 2023 18:41:14 +0800 https://springdoc.cn/spring-boot-enabled-gzip-compression/ 响应压缩是 Web 应用一种常见的优化手段，通过压缩算法减小传输数据的体积，提高传输效率、节约带宽。客户端接收到数据后，使用相同的算法对数据进行解压从而获取到原始数据。 客户端和服务器需要通过 Header 来协商双方支持的压缩算法。 Accept-Encoding：请求头，告诉服务器客户端支持的压缩算法（多个使用逗号分割）。例如：Accept-Encoding: gzip, deflate。 Content-Encoding：响应头，告诉客户端当前 Payload 使用的编码方式（压缩算法）。例如：Content-Encoding: gzip。 常用的压缩算法如下： gzip deflate br JDK 提供了对 GZIP 压缩算法的实现：GZIPOutputStream 和 GZIPInputStream，我们可以用它们来实现 Gzip 压缩和解压缩。 使用 Gzip 压缩响应 在 Spring Boot 应用中创建一个 Controller，使用 GZIPOutputStream 把一张图片文件（20 KB）压缩后响应给客户端。 package cn.springdoc.demo.web.controller; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.Optional; import java.util.zip.GZIPOutputStream; import org.springframework.http.HttpHeaders; import org.springframework.http.MediaType; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletResponse; @RestController @RequestMapping("/demo") public class DemoController { @GetMapping public void file (HttpServletRequest request, HttpServletResponse response) throws IOException { // 20. https://springdoc.cn/spring-mvc-long-polling/ Wed, 15 Nov 2023 17:24:46 +0800 https://springdoc.cn/spring-mvc-long-polling/ 1、概览 长轮询（Long polling）通常用于在 B/S 架构的应用中保持客户端和服务器的连接，直到信息可用。通常在服务器必须调用下游服务以获取信息并等待结果时使用。 本文将带你了解如何在 Spring MVC 应用中使用 DeferredResult 实现长轮询，以及如何处理错误和超时。 2、使用 DeferredResult 进行长轮询 可以在 Spring MVC 中使用 DeferredResult 来异步处理入站 HTTP 请求。它允许释放 HTTP 工作线程来处理其他入站请求，并将工作转移到另一个工作线程。因此，它可以帮助处理需要较长计算或任意等待时间的请求，提高服务的可用性。 2.1、Publisher 使用 DeferredResult 创建一个 Publisher（发布者）应用。 首先，定义一个 Spring @RestController，它可以使用 DeferredResult，但不会将工作转移到另一个工作线程： @RestController @RequestMapping("/api") public class BakeryController { @GetMapping("/bake/{bakedGood}") public DeferredResult<String> publisher(@PathVariable String bakedGood, @RequestParam Integer bakeTime) { DeferredResult<String> output = new DeferredResult<>(); try { Thread.sleep(bakeTime); output.setResult(format("Bake for %s complete and order dispatched. Enjoy!", bakedGood)); } catch (Exception e) { // . https://springdoc.cn/dynamic-authority-in-new-spring-security/ Wed, 15 Nov 2023 17:05:55 +0800 https://springdoc.cn/dynamic-authority-in-new-spring-security/ 在 Spring Boot 3 之后，Spring Security 现在也升级到 Spring Security 6 了。 Spring Security 6 的用法跟之前比起来还是有很大差异，例如：动态权限定义的方式。 1、权限开发思路 先来说权限开发的思路，当设计好 RBAC 权限之后，具体到代码层面，有两种实现思路： 直接在接口/Service 层方法上添加权限注解，这样做的好处是实现简单，但是有一个问题就是权限硬编码，每一个方法需要什么权限都是代码中配置好的，后期如果想通过管理页面修改是不可能的，要修改某一个方法所需要的权限只能改代码。 将请求和权限的关系通过数据库来描述，每一个请求需要什么权限都在数据库中配置好，当请求到达的时候，动态查询，然后判断权限是否满足，这样做的好处是比较灵活，将来需要修改接口和权限之间的关系时，可以通过管理页面点击几下，问题就解决了，不用修改代码。 有人觉得第二种方案无法做到按钮级别的权限控制，这其实是一个误解。想要做到按钮级别的权限控制，只需要数据库中细化配置即可。 2、具体实践 2.1、旧方案回顾 在 vhr 项目中，通过重写两个类来和实现动态权限的。 第一个类是收集权限元数据的类： @Component public class CustomFilterInvocationSecurityMetadataSource implements FilterInvocationSecurityMetadataSource { @Override public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException { //... } @Override public Collection<ConfigAttribute> getAllConfigAttributes() { return null; } @Override public boolean supports(Class<?> clazz) { return true; } } 在 getAttributes 方法中，根据当前请求的 URL 地址（从参数 Object 中可提取出来）和根据权限表中的配置，分析出来当前请求需要哪些权限并返回。 https://springdoc.cn/spring-webflux-timeout/ Wed, 15 Nov 2023 15:21:09 +0800 https://springdoc.cn/spring-webflux-timeout/ 1、概览 WebClient 是一个响应式的 HTTP 客户端，它基于 Reactor 项目提供了函数式 API。 本文将带你了解 WebClient 的超时设置，学习如何正确地设置不同的超时，既包括整个应用程序的全局超时，也包括特定请求的超时。 2、WebClient 和 HTTP 客户端 WebClient 还需要一个 HTTP 客户端库才能正常工作。Spring 为其中一些提供了 内置支持，默认使用的是 Reactor Netty。 大多数配置，包括超时，都可以通过这些客户端完成。 3、通过 HTTP 客户端配置超时 如前所述，在应用中设置不同 WebClient 超时的最简单方法是通过底层 HTTP 客户端进行全局设置。这也是最有效的方法。 由于 Netty 是 Spring WebFlux 的默认客户端库，本文将以 Reactor Netty HttpClient 类 作为示例。 3.1、响应超时 响应超时是指发送请求后等待接收响应的时间。可以使用 responseTimeout() 方法为客户端配置它： HttpClient client = HttpClient.create() .responseTimeout(Duration.ofSeconds(1)); 在本例中，配置的超时时间为 1 秒。Netty 默认不设置响应超时。 然后，就可以使用 HttpClient 来构建 Spring WebClient。 WebClient webClient = WebClient.builder() .clientConnector(new ReactorClientHttpConnector(httpClient)) .build(); 之后，WebClient 会继承底层 HttpClient 提供的所有配置，适用于发送的所有请求。 https://springdoc.cn/spring-boot-react-crud/ Wed, 15 Nov 2023 13:49:49 +0800 https://springdoc.cn/spring-boot-react-crud/ 1、简介 本文将会带你学习如何使用 Spring Boot 以及 React JavaScript 框架开发一个简单的 RESTful CRUD 应用。 2、Spring Boot 2.1、Maven 依赖 在 pom.xml 中添加如下依赖： <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.4.4</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <version>2.4.4</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <version>2.4.4</version> <scope>test</scope> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>1.4.200</version> <scope>runtime</scope> </dependency> </dependencies> 如上，添加了 Web、Test、Spring Data JPA 以及 H2 依赖。 2.2、创建 Model 创建 Client 实体类，有 id、name 和 email 属性： @Entity @Table(name = "client") public class Client { @Id @GeneratedValue private Long id; private String name; private String email; // 省略构造函数和 get/set 方法 } 2. https://springdoc.cn/spring-boot-using-sqlite3/ Tue, 14 Nov 2023 17:47:37 +0800 https://springdoc.cn/spring-boot-using-sqlite3/ SQLite 是一种嵌入式关系型数据库管理系统（RDBMS），使用 C 语言开发，以其简单性、轻量级和零配置而闻名。不需要独立的服务器，可以直接嵌入到应用中。支持事务，支持各种编程语言。是移动应用和嵌入式系统的首选数据库解决方案。 本文将会带你了解如何在 Spring Boot 中配置和使用 SQLite。 创建 Spring Boot 应用 创建一个示例 Spring Boot 应用。在 pom.xml 添加 spring-boot-starter-jdbc 和 SQLite 驱动 sqlite-jdbc 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>org.xerial</groupId> <artifactId>sqlite-jdbc</artifactId> </dependency> sqlite-jdbc 已经被 Spring Boot 纳入了版本控制，所以在项目继承了 spring-boot-starter-parent 的情况下，添加此依赖不用声明版本号。 配置属性 在 application.yaml 中配置如下属性： spring: datasource: type: com.zaxxer.hikari.HikariDataSource driver-class-name: org.sqlite.JDBC url: "jdbc:sqlite:D:\\app.db" 使用默认的数据源实现 HikariDataSource。通过 driver-class-name属性指定 SQLite 的驱动类。url 配置指定了 SQLite 数据库文件的位置，可以是相对路径或者绝对路径。如果文件不存在，会被创建。 测试 得益于 Spring Boot 对数据源开箱即用的支持，完成上述配置后，SQLite 数据库已经就绪可以使用了。 创建测试类： import java.time.LocalDateTime; import java. https://springdoc.cn/spring-webflux-retry/ Tue, 14 Nov 2023 16:30:34 +0800 https://springdoc.cn/spring-webflux-retry/ 1、概览 在云上构建分布式应用时，需要考虑到服务故障，这通常会涉及到重试。 Spring WebFlux 提供了一些失败后重试的工具。 本文将会带你了解如何在 Spring WebFlux 添加和配置重试功能。 2、用例 本文使用一个 MockWebServer 来模拟外部系统暂时不可用，然后又变为可用的情况。 连接到 REST 服务的组件： @Test void givenExternalServiceReturnsError_whenGettingData_thenRetryAndReturnResponse() { mockExternalService.enqueue(new MockResponse() .setResponseCode(SERVICE_UNAVAILABLE.code())); mockExternalService.enqueue(new MockResponse() .setResponseCode(SERVICE_UNAVAILABLE.code())); mockExternalService.enqueue(new MockResponse() .setResponseCode(SERVICE_UNAVAILABLE.code())); mockExternalService.enqueue(new MockResponse() .setBody("stock data")); StepVerifier.create(externalConnector.getData("ABC")) .expectNextMatches(response -> response.equals("stock data")) .verifyComplete(); verifyNumberOfGetRequests(4); } 3、添加重试 Mono 和 Flux API 中内置了两个关键的 retry 操作。 3.1、使用 retry retry 可以防止应用立即返回错误，并重新订阅指定次数： public Mono<String> getData(String stockId) { return webClient.get() .uri(PATH_BY_ID, stockId) .retrieve() .bodyToMono(String.class) .retry(3); } 无论 Web 客户端返回什么错误，都会重试最多三次。 3.2、使用 retryWhen retryWhen 方法可用来创建一个可配置的重试策略： https://springdoc.cn/rest-http-put-vs-post/ Tue, 14 Nov 2023 13:48:32 +0800 https://springdoc.cn/rest-http-put-vs-post/ 1、概览 在设计 RESTful API 的时候，往往会纠结于到底是用 PUT 还是 POST 请求？ 本文将会带你了解在 RESTful API 中 PUT 和 POST 请求之间的区别以及它们的应用场景。 2、PUT 与 POST 在典型的 REST 架构中，客户端以 HTTP 方法的形式向服务器发送请求，以创建、检索、修改或删除资源。虽然可以使用 PUT 和 POST 来创建资源，但它们在预期应用方面有很大的不同。 根据 RFC 2616 标准，POST 方法应该用于请求服务器将所附实体作为现有资源（由请求 URI 标识）的子级接受。这意味着使用 POST 方法调用将在资源集合下创建一个子资源。 相反，PUT 方法应该用于请求服务器将所附实体存储在请求的 URI 下。如果请求 URI 指向服务器上的现有资源，则提供的实体将被视为现有资源的修改版本。因此，PUT 方法调用要么创建一个新资源，要么更新现有资源。 这两种方法的另一个重要区别是，PUT 是一种幂等方法，而 POST 不是。例如，多次调用 PUT 方法将创建或更新同一资源。相比之下，多次 POST 请求将导致多次创建同一资源。 3、示例应用 使用 Spring Boot 创建一个简单的 RESTful Web 应用来演示 PUT 和 POST 请求的区别。 3.1、Maven 依赖 需要在 pom.xml 中添加 Spring Web、Spring Data JPA 和 H2 内存数据库依赖： https://springdoc.cn/spring-mvc-handlerinterceptor-vs-filter/ Tue, 14 Nov 2023 12:12:10 +0800 https://springdoc.cn/spring-mvc-handlerinterceptor-vs-filter/ 1、概览 本文将会带你了解 Spring MVC HandlerInterceptor 和 Servlet Filter 之间的区别和各自的应用场景。 2、Filter Filter 是 Web 服务器的一部分，而不是 Spring 框架的组件。对于传入请求，可以使用 Filter 来操作甚至阻止请求到达任何 Servlet。反之亦然，也可以阻止响应到达客户端。 Spring Security 就是使用 Filter 进行身份认证和授权的一个很好的例子。要配置 Spring Security，只需添加一个 Filter，即 DelegatingFilterProxy。这样，Spring Security 就能拦截所有进出流量。这就是 Spring Security 可以在 Spring MVC 之外使用的原因。 2.1、创建 Filter 创建一个实现 jakarta.servlet.Filter 接口的 Filter 实现类： public class LogFilter implements Filter { private Logger logger = LoggerFactory.getLogger(LogFilter.class); @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { logger.info("Hello from: " + request. https://springdoc.cn/spring-boot-multipart-requests/ Tue, 14 Nov 2023 11:34:12 +0800 https://springdoc.cn/spring-boot-multipart-requests/ 1、简介 本文将带你了解如何在 Spring Boot 项目中处理 Multipart 文件上传请求。 Multipart 请求可以包含多个独立的请求体部分，通常用于文件上传。除了文件以外，还可以同时上传表单、JSON、XML 等等数据。 2、使用 @ModelAttribute 一个简单的示例，使用表单发送包含了员工姓名和文件的数据。 创建 Employee 类： public class Employee { private String name; private MultipartFile document; } 然后，使用 Thymeleaf 渲染表单： <form action="#" th:action="@{/employee}" th:object="${employee}" method="post" enctype="multipart/form-data"> <p>name: <input type="text" th:field="*{name}" /></p> <p>document:<input type="file" th:field="*{document}" multiple="multiple"/> <input type="submit" value="upload" /> <input type="reset" value="Reset" /></p> </form> 注意，需要将表单的 enctype 属性声明为 multipart/form-data。 最后，创建一个接受表单数据（包括 Multipart 文件）的方法： @RequestMapping(path = "/employee", method = POST, consumes = { MediaType. https://springdoc.cn/spring-boot-docker-minio/ Mon, 13 Nov 2023 15:55:14 +0800 https://springdoc.cn/spring-boot-docker-minio/ Minio 是一个用 Golang 开发的开源的对象存储服务器，它基于 Amazon S3 协议，提供了简单而强大的存储解决方案。可以在本地部署或云环境中使用。也支持分布式部署，并具有高可用性和容错性。 本文将会带你了解如何在 Linux 中通过 Docker 的方式来安装、配置 Minio，以及如何在 Spring Boot 应用中通过 Minio 官方 SDK 上传文件资源到 Minio 服务器。 安装 Minio 在 Linux 下，使用 Docker 的方式安装 Minio 最简单。首先确保你在服务器上安装了 Docker，并且需要 root 用户来执行下面的安装过程。 首先，创建存放文件资源的目录： mkdir -p ~/minio/data 上述命令在 $HOME 目录下创建了 /minio/data 文件夹，用于存放资源。 接着，使用 Docker 运行 Minio 容器： docker run \ -d \ -p 9000:9000 \ -p 9090:9090 \ --name minio-server \ -v ~/minio/data:/data \ -e "MINIO_ROOT_USER=admin" \ -e "MINIO_ROOT_PASSWORD=minio858896" \ quay. https://springdoc.cn/spring-aliasfor-annotation/ Mon, 13 Nov 2023 14:38:25 +0800 https://springdoc.cn/spring-aliasfor-annotation/ 1、概览 本文将会带你了解 Spring 中的 @AliasFor 注解。 首先介绍一些框架中的使用示例，最后看看如何在自定义注解中使用 @AliasFor。 2、注解 @AliasFor 自 4.2 版起成为框架的一部分。多个 Spring 核心注解已更新为包含此注解。 可以将其用于装饰单个注解中的属性，或者在由元注解组成的注解中使用。元注解是可以应用于其他注解的注解。 在同一个注解中，使用 @AliasFor 来声明属性的别名，这样就可以交替使用它们。或者，可以在组合注解中使用 @AliasFor 来覆盖元注解中的属性。换句话说，当使用 @AliasFor 在组合注解中装饰属性时，它会覆盖其元注解中的指定属性。 许多核心 Spring 注解，如 @Bean、@ComponentScan、@Scope、@RequestMapping 和 @RestController 现在都使用 @AliasFor 来配置其内部属性别名。 @AliasFor 注解的定义如下： @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @Documented public @interface AliasFor { @AliasFor("attribute") String value() default ""; @AliasFor("value") String attribute() default ""; Class<? extends Annotation> annotation() default Annotation.class; } 既可以隐式地使用这个注解，也可以显式地使用它。隐式使用仅限于注解内部的别名。相比之下，显式使用还可以用于元注解中的属性。 3、注解中的显示别名 参考 Spring 的核心注解 @ComponentScan： @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Documented @Repeatable(ComponentScans.class) public @interface ComponentScan { @AliasFor("basePackages") String[] value() default {}; @AliasFor("value") String[] basePackages() default {}; . https://springdoc.cn/spring-conditional-annotations/ Mon, 13 Nov 2023 13:31:10 +0800 https://springdoc.cn/spring-conditional-annotations/ 1、简介 本文将带你了解 Spring 中的 @Conditional 注解。它用于根据特定条件来控制 Bean 的创建和注册。 2、声明条件 首先来看看在哪些情况下可以使用条件注解。 最常见的用法是包含或排除整个配置类： @Configuration @Conditional(IsDevEnvCondition.class) class DevEnvLoggingConfiguration { } 或者是一个 Bean： @Configuration class DevEnvLoggingConfiguration { @Bean @Conditional(IsDevEnvCondition.class) LoggingService loggingService() { return new LoggingService(); } } 如上，这样就可以根据特定条件（如环境类型或特定需求）来调整应用的行为。在上例中，只为开发环境初始化了额外的 LoggingService。 另一种方式是直接在组件类上放置条件。 @Service @Conditional(IsDevEnvCondition.class) class LoggingService { // ... } 可以将上述示例应用于任何使用 @Component、@Service、@Repository 或 @Controller 注解声明的 Bean。 3、预定义条件注解 Spring 自带一组预定义的条件注解。 首先，看看如何根据配置的属性值来创建组件： @Service @ConditionalOnProperty( value="logging.enabled", havingValue = "true", matchIfMissing = true) class LoggingService { // ... } 第一个属性 value 指定了要匹配的配置属性。第二个属性 havingValue 定义了该条件所需的值。最后，matchIfMissing 属性告诉 Spring，如果参数缺失，是否应匹配该条件。 https://springdoc.cn/spring-boot-application-context-exception/ Mon, 13 Nov 2023 11:57:43 +0800 https://springdoc.cn/spring-boot-application-context-exception/ 1、概览 本文将会带你了解在 Spring Boot 启动时出现 ApplicationContextException 异常的原因，以及解决办法： ApplicationContextException: Unable to start ServletWebServerApplicationContext due to missing ServletWebServerFactory bean 2、可能的原因 异常信息，“由于缺少 ServletWebServerFactory Bean，无法启动 ServletWebServerApplicationContext” 说明了一切。ApplicationContext 中没有配置 ServletWebServerFactory Bean。 该异常主要出现在 Spring Boot 无法启动 ServletWebServerApplicationContext 时。为什么会这样？因为 ServletWebServerApplicationContext 使用包含的 ServletWebServerFactory Bean 来启动自身。 一般来说，Spring Boot 通过 SpringApplication.run 方法来启动 Spring 应用。 SpringApplication 类会根据应用类型（如，Web 应用），尝试创建正确的 ApplicationContext。 用于确定是否是 Web 应用的算法来自于一些依赖，如 spring-boot-starter-web。缺少这些依赖，可能是导致异常的原因之一。 另一个原因是 Spring Boot 启动类中缺少 @SpringBootApplication 注解。 3、重现异常 创建一个示例应用，故意在 main 类上不添加 @SpringBootApplication 注解。 public class MainEntryPoint { public static void main(String[] args) { SpringApplication. https://springdoc.cn/java-feign-logging/ Mon, 13 Nov 2023 11:26:02 +0800 https://springdoc.cn/java-feign-logging/ 1、概览 本文将带你了解如何在 Spring Boot 中配置 Feign 客户端的日志级别。 2、Feign 客户端 Feign 是一个声明式的 HTTP 客户端，通过注解来处理模板代码。只需提供一个带注解的接口，运行时会根据注解定义创建实际的实现。 3、日志配置 要启用日志记录，需要将应用中包含 Feign 客户端的类或包的日志记录级别设置为 DEBUG。 给一个类设置日志级别： logging.level.<packageName>.<className> = DEBUG 如果 Feign 接口都在同一个包下，也可以直接为整个 package 设置日志级别： logging.level.<packageName> = DEBUG 接着，需要设置 feign 客户端的日志级别。注意，上一步只是启用日志记录。 有四种日志级别可供选择： NONE：无日志记录（默认） BASIC：记录基本信息，包括请求方法和 URL 以及响应状态码和执行时间 HEADERS：记录基本信息以及请求和响应的 Header FULL：记录请求和响应的 Header、Body 和元数据 可以通过 Java 配置类或在 properties 文件中进行配置。 3.1、Java 配置 声明一个配置类 FeignConfig： public class FeignConfig { @Bean Logger.Level feignLoggerLevel() { return Logger.Level.FULL; } } 然后，把配置类设置到 Feign 客户端接口 FooClient 中： @FeignClient(name = "foo-client", configuration = FeignConfig. https://springdoc.cn/spring-boot-freemarker-i18n/ Sun, 12 Nov 2023 17:49:33 +0800 https://springdoc.cn/spring-boot-freemarker-i18n/ i18n（Internationalization），即国际化。目的是为了使软件、应用或网站能够适应不同的语言、地区，用户可以选择他们熟悉的语言进行交互，为所有用户提供一致的体验。 本文将会带你了解如何使用 Spring Boot + Freemarker 实现国际化。 假设我们有一个登录页面，其中有 2 个输入框，分别用于输入 用户名 和 密码。对于使用不同语言的用户，需要显示不同的输入框名称。 创建项目 在 pom.xml 中添加 web 和 freemarker stater 依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-freemarker</artifactId> </dependency> 配置 定义国际化资源文件 通常我们会把项目中需要国际化的内容定义在不同的 properties 文件中，通过 properties 文件名的后缀来表示资源的 语言 和 国别。 在 resources 目录下创建 i18n 目录，用于存放国际化资源文件。接着，在 i18n 目录中创建如下 3 个 properties 文件，如下： message.properties # message.properties 的内容 # 空着就行 message_en_US.properties # message_en_US.properties 的内容 # 英文 login.username=USERNAME login.password=PASSWORD message_zh_CN.properties # message_zh_CN.properties 的内容 # 中文 login. https://springdoc.cn/spring-service-layer-validation/ Sun, 12 Nov 2023 15:57:38 +0800 https://springdoc.cn/spring-service-layer-validation/ 1、概览 本文将带你了解如何在 Spring 应用的 Service 层中使用 Spring Validation 进行校验。 2、应用分层 Spring Web 应用通常分为如下几层： Consumer 层或 Web 层是 Web 应用程序的最上层。它负责解析用户的输入并提供适当的响应。其他层抛出的异常也必须由 Web 层处理。由于 Web 层是应用程序的入口点，因此它负责身份认证，是防止未授权用户的第一道防线。 在 Web 层之下是 Service 层。它充当事务屏障，同时承载应用和基础设施服务。Service 层的公共 API 由应用服务提供。它们通常作为事务边界，并负责授权事务。基础设施服务提供与外部工具（包括文件系统、数据库和电子邮件服务器）连接的 “管道代码”。这些方法通常被多个应用服务使用。 Web 应用的最底层是持久层。换句话说，它负责与数据存储进行交互。 3、Service 层的验证 Service 层是应用中的一个层，用于在 Controller 和持久层之间进行通信。此外，业务逻辑也存储在 Service 层中。其中特别包括验证逻辑。Model 状态用于 Controller 层和 Service 层之间的通信。 在业务层进行验证逻辑有其优点和缺点。Spring 的验证（和数据绑定）架构并不排除任何一种方式。验证未绑定在 Web 层，这易于本地化，并且允许使用任何可用的 Validator。 此外，客户端输入数据并不总是通过 REST Controller 处理，如果不在 Service 层进行验证，非法数据可能会通过，引发多个问题。 在这种情况下，可以使用标准的 Java JSR-303 验证方案。 4、示例 使用 Spring Boot 开发一个简单的用户注册应用。 4.1、Domain 只有 name、age、phone 和 password 属性： https://springdoc.cn/spring-boot-max-http-header-size/ Sun, 12 Nov 2023 15:18:41 +0800 https://springdoc.cn/spring-boot-max-http-header-size/ 1、概览 Spring Boot Web 应用默认包含一个预配置的嵌入式 Web 服务器。有时候需要对这个服务器进行一些定制来满足特殊的需求。 本文将会带你了解如何在 Spring Boot 应用中通过 max-http-header-size 配置属性来限制客户端的 Header 大小。 2、Max-HTTP-Header-Size Spring Boot 支持将 Tomcat、Undertow 和 Jetty 作为嵌入式服务器。通常，会在 Spring Boot 应用的 application.properties 文件或 application.yaml 文件中定义服务器配置。 大多数 Web 服务器对 HTTP 请求头有自己的大小限制。HTTP 请求头的值受服务器实现的限制。在 Spring Boot 应用中，可以使用 server.max-http-header-size 配置属性来配置最大允许的 HTTP Header 的大小 Tomcat 和 Jetty 的默认值为 8kB，而 Undertow 的默认值为 1MB。 在 application.properties 文件中添加该属性，修改最大 HTTP Header 大小： server.max-http-header-size=20000 同样，application.yaml 格式也是如此： server: max-http-header-size: 20000 从 Spring Boot 2.1 开始，可以使用 DataSize 格式的值： https://springdoc.cn/spring-native-intro/ Sun, 12 Nov 2023 12:26:23 +0800 https://springdoc.cn/spring-native-intro/ 1、概览 本年将带你了解原生镜像（Native Image）的相关知识，以及如何使用 Spring Boot 和 GraalVM 构建原生镜像应用。 本文使用的是 Spring Boot 3，但是在末尾会教你如何解决与 Spring Boot 2 的差异问题。 2、原生镜像 原生（本地）镜像是一种将 Java 代码构建为独立可执行文件的技术。该可执行文件包括应用程序类、其依赖项的类、运行时库类以及来自 JDK 的静态链接本地代码。JVM 被打包到原生镜像中，因此在目标系统上不需要任何 Java 运行环境，但构建产物依赖于平台。因此，需要为每个支持的目标系统进行一次构建，在使用 Docker 等容器技术时会更加简单，将容器构建为一个目标系统，可以部署到任何 Docker 运行时。 2.1、GraalVM 和 Native Image Builder 通用递归应用和算法语言虚拟机（Graal VM）是一个高性能的 JDK 发行版，专为 Java 和其他 JVM 语言编写，同时支持 JavaScript、Ruby、Python 和其他几种语言。它提供了一个原生镜像生成器（Native Image builder），这是一个从 Java 应用中生成原生代码并将其与 VM 一起打包成独立可执行文件的工具。Spring Boot Maven 和 Gradle Plugin 除了少数 例外情况（Mockito 目前不支持原生测试），正式支持该工具。 2.2、两个特性 在构建原生镜像时，会遇到两个典型特性。 Ahead-Of-Time（AOT）编译是将高级 Java 代码编译成本地可执行代码的过程。通常由 JVM 的即时编译器 (JIT) 在运行时进行编译，这样可以在执行应用程序时进行观察和优化。在 AOT 编译的情况下，这一优势就不复存在了。 通常，在进行 AOT（Ahead-of-Time）编译之前，可以选择进行一个单独的步骤，称为 AOT 处理，即从代码中收集元数据并提供给 AOT 编译器。将这两个步骤分开是有意义的，因为 AOT 处理可以是针对特定框架的，而 AOT 编译器更加通用。下面的图片给出了一个概览： https://springdoc.cn/log4j-to-syslog/ Sun, 12 Nov 2023 11:23:10 +0800 https://springdoc.cn/log4j-to-syslog/ 1、概览 日志是每个应用的重要组成部分。在应用中，可以将日志存储在文件或数据库中。除此以外，还可以将日志数据发送到集中式日志管理应用，如 Graylog 或 Syslog。 本文将带你了解如何在 Spring Boot 应用中使用 Log4j2 将日志信息发送到 Syslog 服务器。 2、Log4j2 Log4j2 是 Log4j 的最新版本。它是高性能日志记录的常见选择，并被广泛应用于许多生产应用中。 2.1、Maven 依赖 在 pom.xml 中添加 spring-boot-starter-log4j2 依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-log4j2</artifactId> <version>2.5.2</version> </dependency> 要在 Spring Boot 应用中配置 Log4j2，需要从 pom.xml 中的任何 Starter 中排除默认的 Logback 日志框架。 在本文示例项目中，只有 spring-boot-starter-web Starter 依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <exclusions> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-logging</artifactId> </exclusion> </exclusions> </dependency> 2.2、Log4j2 配置 现在，创建 Log4j2 配置文件。Spring Boot 会在 classpath 中搜索 log4j2-spring.xml 或 log4j2.xml 文件。 在 resource 目录中配置一个示例 log4j2-spring. https://springdoc.cn/spring-mvc-set-json-content-type/ Sun, 12 Nov 2023 10:45:40 +0800 https://springdoc.cn/spring-mvc-set-json-content-type/ 1、简介 Content Type 表示请求/响应数据的媒体类型（Media Type）。当 Conroller 收到 Web 请求时，它会根据 Content Type 解析请求数据，然后根据 Content Type 响应数据。目前在 REST 中最流行的 Content Type 就是 JSON。 本文将会带你了解如何在 Spring MVC 中设置请求和响应的 Content Type。 2、@RequestMapping 注解 简而言之，@RequestMapping 是将 Web 请求映射到 Spring Controller 的重要注解。它有各种属性，包括 HTTP 方法、请求参数、Header 和媒体类型。 一般来说，媒体类型分为两类：消费（请求）、生产（响应）。也可以在 Spring 中定义自定义媒体类型。 其目的在于限制 Handler 可消费、生产的媒体类型。 2.1、请求的媒体类型 通过 consumes 属性指定 Controller 可接受的媒体类型，可以有多个。 定义一个简单的端点： @RequestMapping(value = "/greetings", method = RequestMethod.POST, consumes="application/json") public void addGreeting(@RequestBody ContentType type, Model model) { } 如果 Controller 不支持客户端指定的媒体类型，则会返回 HTTP “415 Unsupported Media Type” 错误。 https://springdoc.cn/spring-enablewebsecurity-vs-enableglobalmethodsecurity/ Sat, 11 Nov 2023 20:17:15 +0800 https://springdoc.cn/spring-enablewebsecurity-vs-enableglobalmethodsecurity/ 1、概览 有时我们需要在 Spring Boot 应用的不同路径上应用多个 Security Filter。 本文将带你了解在 Spring Scurity 中自定义 Security 的两种方法 - 通过使用 @EnableWebSecurity 和 @EnableGlobalMethodSecurity。 本文通过一个简单的应用示例来说明这两者的区别。该应用包含一些管理员（ADMIN）才能访问的资源和一些只有认证了的用户（USER）才能访问的资源以及一些任何人都可以访问、下载的公共资源。 2、Spring Boot 整合 Spring Security 2.1、Maven 依赖 无论采用哪种方法，都需要添加 Spring Boot Stater 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> 2.2、Spring Boot 自动配置 当 classpath 上存在 Spring Security 时，Spring Boot Security Auto-Configuration 的 WebSecurityEnablerConfiguration 就会激活 @EnableWebSecurity。这会在应用中加载默认的安全配置。 默认的安全配置会激活 HTTP Security Filter 和 Security Filter Chain，并对端点应用 Basic Authentication 认证。 3、保护端点 第一种方式，创建一个 MySecurityConfigurer 类，使用 @EnableWebSecurity 对其进行注解。 @EnableWebSecurity public class MySecurityConfigurer { } 3. https://springdoc.cn/spring-boot-change-log4j2-location/ Sat, 11 Nov 2023 13:30:36 +0800 https://springdoc.cn/spring-boot-change-log4j2-location/ 1、概览 本文将会带你了解如何在 Spring Boot 应用中修改 Log4j2 配置文件的默认位置。 2、通过配置文件更改 默认情况下，把 Log4j2 配置文件（log4j2.xml / log4j2-spring.xml）放在项目的 classpath 或 resources 文件夹中。 可以在 application.properties 中修改该文件的位置： logging.config=/path/to/log4j2.xml 3、通过 VM 参数修改 还可以在运行程序时通过以下 VM 参数来指定 log4j2 的配置文件： -Dlogging.config=/path/to/log4j2.xml 4、编程式配置 最后，还可以通过更改 Spring Boot Application 类，以编程方式配置该文件的位置： @SpringBootApplication public class Application implements CommandLineRunner { public static void main(String[] args) { SpringApplication.run(Application.class, args); } @Override public void run(String... param) { // Log4j2 的 Configurator 类 Configurator.initialize(null, "/path/to/log4j2.xml"); } } 这种解决方案有一个缺点：应用启动过程不会使用 Log4j2 输出日志。 https://springdoc.cn/spring-context-vs-servlet-path/ Sat, 11 Nov 2023 13:06:08 +0800 https://springdoc.cn/spring-context-vs-servlet-path/ 1、简介 DispatcherServlet 在 Spring 应用中扮演着重要角色，它为应用提供了一个入口点。Context Path 定义了终端用户访问应用的 URL。 本文将带你了解 Spring 中 Context Path（上下文路径）与 Servlet Path（Servlet 路径）的区别。 2、Context Path 简而言之，Context Path 是访问 Web 应用时使用的名称。它是应用的根路径。默认情况下，Spring Boot 在 ROOT 上下文路径（"/"）上提供服务。 因此，默认情况下，Spring Boot 应用可以通过 http://localhost:8080/ 访问。 不过，在某些情况下，我们可能需要更改应用的 Context。配置 Context Path 有多种方法，最简单的方式就是通过位于 src/main/resources 文件夹下的 application.properties 进行配置。 server.servlet.context-path=/demo 如上，此时应用的主页为： http://localhost:8080/demo 特别是在把应用部署到外部服务器时，往往需要修改应用的 Context Path，以便于其他一起部署的应用分开来。 3、Servlet Path Servlet Path 表示 DispatcherServlet 的 Path。DispatcherServlet 是一个实际的 Servlet，继承自 HttpSerlvet 。默认值与 Context Path 类似，即（“/”）： spring.mvc.servlet.path=/ 在 Boot 的早期版本中，该属性位于 ServerProperties 类中，名称为 server.servlet-path=/。 从 2. https://springdoc.cn/kafka-custom-serializer/ Sat, 11 Nov 2023 12:30:55 +0800 https://springdoc.cn/kafka-custom-serializer/ 1、简介 在 Apache Kafka 中传输消息时，客户端和服务器会就使用共同的语法格式达成协议。Apache Kafka 提供了默认的转换器（Converter），如 String 和 Long。同时也支持针对特定用例的自定义序列化器 （Serializer）。 2、Apache Kafka 中的 Serializer 序列化是将对象转换为字节的过程。反序列化则是将字节流转换为对象的逆过程。简而言之，它将内容转换为可读和可解释的信息。 如上所述，Apache Kafka 为几种基本类型提供了默认序列化器，并允许我们实现自定义序列化器： 上图显示了通过网络向 Kafka Topic 发送消息的过程。在此过程中，生产者将消息发送到 Topic 之前，自定义序列化器会将对象转换成字节。同样，它也显示了反序列化器如何将字节转换回对象，以便消费者正确处理。 2.1、自定义 Serializer Apache Kafka 为几种基本类型提供了预置的序列化器和反序列化器： StringSerializer ShortSerializer IntegerSerializer LongSerializer DoubleSerializer BytesSerializer 它也提供了实现自定义序列化器/反序列化器的功能。为了序列化自己的对象，需要实现 Serializer 接口。同样，要创建自定义的反序列化器，需要实现 Deserializer 接口。 这两个接口都有可覆写的方法： configure：用于实现配置细节 serialize / deserialize：这些方法包括自定义序列化和反序列化的实际实现 close：使用该方法关闭 Kafka Session 3、实现自定义 Serializer Kafka 提供了自定义序列化器的功能。可以为消息的 Key 和 Value 实现特定的转换器（Converter）。 3.1、依赖 在 pom.xml 中添加 Kafka Consumer API 依赖： <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka-clients</artifactId> <version>3.4.0</version> </dependency> 3. https://springdoc.cn/spring-boot-kafka-ssl/ Sat, 11 Nov 2023 09:58:08 +0800 https://springdoc.cn/spring-boot-kafka-ssl/ 1、简介 本文将带你了解在 Spring Boot 中如何配置 SSL 认证以连接到 Apache Kafka Broker。 安全套接字层（SSL）实际上已被弃用，自 2015 年起被传输层安全（TLS）所取代。不过，由于历史原因，Kafka（和 Java）仍然使用 “SSL”。 2、SSL 概览 默认情况下，Apache Kafka 以明文形式发送所有数据，且不进行任何身份认证。 首先，可以为 Broker 和客户端之间的加密配置 SSL。默认情况下，这需要使用公钥加密进行单向身份认证，由客户端验证服务器证书。 此外，服务器还可以使用单独的机制（如 SSL 或 SASL）对客户端进行身份认证，从而实现双向身份认证或相互 TLS（mTLS）。基本上，双向 SSL 认证确保客户端和服务器都使用 SSL 证书来认证对方的身份，并在双向上相互信任。 在本文中，Broker 使用 SSL 对客户端进行身份验证，使用 Keystore 和 Truststore 保存证书和密钥。 每个 Broker 都需要自己的 Keystore，其中包含私钥和公共证书。客户端使用其 Truststore 来验证该证书并信任服务器。同样，每个客户端也需要自己的 Keystore，其中包含私钥和公共证书。服务器使用其 Truststore 来验证和信任客户端的证书，并建立安全连接。 Truststore 可以包含一个可以签署证书的证书颁发机构（CA）。在这种情况下，Broker 或客户端会信任由 Truststore 中的 CA 签发的任何证书。这就简化了证书验证，因为添加新客户端或 Broker 无需更改 Truststore。 3、依赖和设置 创建一个简单的 Spring Boot 示例应用，在 pom.xml 中添加 spring-kafka 依赖： <dependency> <groupId>org. https://springdoc.cn/postman-websocket-apis/ Sat, 11 Nov 2023 09:27:43 +0800 https://springdoc.cn/postman-websocket-apis/ 1、概览 本文将会带你了解如何使用 spring-websockets 创建一个 Websocket 应用，并且使用 Postman 来进行测试。 2、Java WebSocket WebSocket 是 Web 浏览器和服务器之间的一种双向、全双工、持久连接。一旦建立了 WebSocket 连接，该连接就会一直打开，直到客户端或服务器决定关闭该连接。 WebSocket 协议是实现应用处理实时消息的一种方式之一。最常见的替代方案是长轮询（long polling）和服务器推送事件（server-sent events）。每种解决方案都有其优点和缺点。 在 Spring 中使用 WebSockets 的一种方式是使用 STOMP 子协议。不过，本文使用原始 WebSockets，因为到目前为止，Postman 还不支持 STOMP。 3、Postman Postman 是一个用于构建和使用 API 的 API 平台。使用 Postman 时，无需为了测试而编写 HTTP 客户端基础设施代码。相反，可以创建称为集合（collections）的测试套件，并让 Postman 与 API 进行交互。 4、WebSocket 应用 创建一个简单的应用，工作流程如下： 服务器向客户端发送一次性消息 服务器定期向客户端发送消息 从客户端接收消息时，通过日志记录消息并将其发送回客户端 客户端向服务器发送非周期性消息 客户端接收来自服务器的消息并将其输出到日志 程图如下： 5、Spring WebSocket 服务器由两部分组成。Spring WebSocket Event Handler（事件处理器）和 Spring WebSocket 配置。 5.1、Spring WebSocket 配置 在配置类上添加 @EnableWebSocket 注解，可以在 Spring 服务器中启用 WebSocket 支持。 https://springdoc.cn/webclient-upload-file/ Fri, 10 Nov 2023 13:52:27 +0800 https://springdoc.cn/webclient-upload-file/ 1、概览 文件上传是现在应用中很常见的需求，从 Spring 5 开始可以通过响应式上传文件。有了响应式编程的加持，能够使用较少的线程和背压（Backpressure）机制，以非阻塞的方式进行上传。 本文将带你了解使用 WebClient（一种非阻塞、响应式的 HTTP 客户端）通过 BodyInserters 上传文件的两种不同方法。WebClient 是名为 Project Reactor 的响应式编程库的一部分。 2、使用 WebClient 上传文件 首先，在项目中添加 spring-boot-starter-webflux 依赖： <dependency> <groupId>org.springframework.boot</groupId>. <artifactId>spring-boot-starter-webflux</artifactId> </dependency> 2.1、上传单个文件 首先，声明上传地址的 URL： URI url = UriComponentsBuilder.fromHttpUrl(EXTERNAL_UPLOAD_URL).build().toUri(); 比方说，在本例中要上传 PDF。因此使用 MediaType.APPLICATION_PDF 作为 ContentType。上传端点会返回一个 HttpStatus。由于只希望得到一个结果，所以将其封装在一个 Mono 中： Mono<HttpStatus> httpStatusMono = webClient.post() .uri(url) .contentType(MediaType.APPLICATION_PDF) .body(BodyInserters.fromResource(resource)) .exchangeToMono(response -> { if (response.statusCode().equals(HttpStatus.OK)) { return response.bodyToMono(HttpStatus.class).thenReturn(response.statusCode()); } else { throw new ServiceException("Error uploading file"); } }); 调用这个方法的方法也可以返回一个 Mono，可以一直进行下去，直到真正需要访问结果为止。就绪后，可以在 Mono 对象上调用 block() 方法。 https://springdoc.cn/spring-log4j2-config-per-profile/ Fri, 10 Nov 2023 13:38:27 +0800 https://springdoc.cn/spring-log4j2-config-per-profile/ 1、概览 本文将带你了解如何在 Spring Boot 中根据不同的 Profile 激活不同的 Log4j2 配置。 2、使用不同的配置文件 例如，假设我们有两个文件：log4j2.xml 和 log4j2-dev.xml，一个用于默认配置文件，另一个用于 dev Profile。 创建 application.properties 文件，指定日志配置文件： logging.config=/path/to/log4j2.xml 接着，为 dev Profile 创建一个名为 application-dev.properties 的新 properties 文件，并添加类似的日志配置： logging.config=/path/to/log4j2-dev.xml 如果还有其他的 Profile，例如 prod，只需为其创建一个名称相似的 properties 文件 - application-prod.properties。特定 Profile 的属性总是优先于默认属性。 3、编程式配置 可以通过更改 Spring Boot Application 类，以编程方式选择使用哪个 Log4j2 配置文件： @SpringBootApplication public class Application implements CommandLineRunner { @Autowired private Environment env; public static void main(String[] args) { SpringApplication.run(Application.class, args); } @Override public void run(String... param) { if (Arrays. https://springdoc.cn/spring-applicationcontext-vs-spring-servlet-xml/ Fri, 10 Nov 2023 12:57:37 +0800 https://springdoc.cn/spring-applicationcontext-vs-spring-servlet-xml/ 1、简介 所有 Java Web 框架都建立在 Servlet Api 的基础之上。在基于 Spring 开发的 Java Web 应用中，有三个文件起着至关重要的作用。通常，按以下顺序将它们串联起来：web.xml -> applicationContext.xml -> spring-servlet.xml。 本文将带你了解 applicationContext.xml 和 spring-servlet.xml 之间的区别。 2、applicationContext.xml 反转控制（IoC）是 Spring 的核心。在使用 IoC 的框架中，通常由容器负责实例化、创建和删除对象。在 Spring 中，applicationContext 就扮演着 IoC 容器的角色。 在开发标准 J2EE 应用时，会在 web.xml 文件中声明 ContextLoaderListener。此外，还定义了一个 contextConfigLocation 来指定 XML 配置文件。 <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext*.xml</param-value> </context-param> 应用启动时，Spring 会加载该配置文件，并使用它创建 WebApplicationContext 对象。如果没有 contextConfigLocation，默认情况下，系统将查找 /WEB-INF/applicationContext.xml 来加载。 简而言之，applicationContext 是 Spring 的核心接口。它为应用提供配置信息。 在该文件中，提供了与应用相关的配置。通常，这些配置包括基本数据源、属性占位符文件（Property Place Holder）和用于项目本地化的消息源（Message Source），以及其他增强功能。 示例如下： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:c="http://www.springframework.org/schema/c" xmlns:p="http://www. https://springdoc.cn/table-partitioning-spring-hibernate/ Fri, 10 Nov 2023 11:18:26 +0800 https://springdoc.cn/table-partitioning-spring-hibernate/ 简介 本文将带你了解如何使用 Spring 和 Hibernate 实现表分区。 表分区的目标是将一个大型表分割为多个较小的分区表，以便关联的表和索引记录可以放入内存缓冲池，从而实现更高效的查找或扫描操作。 使用 PostgreSQL 进行表分区 PostgreSQL 为 表分区 提供了三种策略： 列表分区（List Partitioning） 范围分区（Range Partitioning） Hash 分区（Hash Partitioning） 本例使用列表分区，按大洲来划分数据表。 例如，users 分区如下： CREATE TABLE users ( id bigint NOT NULL, first_name varchar(255), last_name varchar(255), registered_on timestamp(6), partition_key varchar(255), PRIMARY KEY (id, partition_key) ) PARTITION BY LIST (partition_key) CREATE TABLE users_asia PARTITION OF users FOR VALUES IN ('Asia') CREATE TABLE users_africa PARTITION OF users FOR VALUES IN ('Africa') CREATE TABLE users_north_america PARTITION OF users FOR VALUES IN ('North America') CREATE TABLE users_south_america PARTITION OF users FOR VALUES IN ('South America') CREATE TABLE users_europe PARTITION OF users FOR VALUES IN ('Europe') CREATE TABLE users_australia PARTITION OF users FOR VALUES IN ('Australia') posts 表分区如下： https://springdoc.cn/monitoring-a-directory-in-spring-boot/ Fri, 10 Nov 2023 10:30:14 +0800 https://springdoc.cn/monitoring-a-directory-in-spring-boot/ 概览 有时我们需要在应用中监控本地磁盘上的某个目录，在目录中的文件发生变化时（创建、编辑、删除）进行相应的处理。 在 Java 中有好几种方式可以实现监控目录。 Java WatchService API：在 Java 7 中引入，属于低级 API。 Apache commons io：提供了一个用于监控文件系统事件的组件。 Spring Integration 的文件支持：这是 Spring integration 项目的一部分，该项目支持多种企业集成模式。 Spring Boot Developer Tools 中的 Filewatch： 它可以观察本地文件系统的变化。 本文将带你了解如何通过 Spring Boot Developer Tools 中的 Filewatch 来监控系统目录。它本身就是基于 Spring 构建，所以可以和 Spring Boot 无缝集成。 用例 我们希望通过将 csv 文件复制到特定位置（目录）来在应用中创建新的客户。一旦文件完全传输完成，就对其进行读取。然后，对 csv 文件进行验证、处理并移动到目标目录。以下是csv文件的示例： name, email, dob, info, vip James Hart,james.hart@gmail.com,12/05/2002,Information for James,No Will Avery,will.avery@gmail.com,23/10/1991,Information for Will,Yes Anne Williams,anne.williams@gmail.com,12/05/1975,Information for Anne,No Julia Norton,julia.norton@gmail.com,23/10/1984,Information for Julia,Yes csv 文件始终包含标题行和按特定顺序排列的 5 列。 https://springdoc.cn/spring-boot-jooq-tutorial-fetching-many-to-many-associations/ Thu, 09 Nov 2023 11:59:54 +0800 https://springdoc.cn/spring-boot-jooq-tutorial-fetching-many-to-many-associations/ 上一教程 介绍了如何使用 jOOQ 检索一对多关系的记录。本文将带你了解如何使用 jOOQ 检索多对多关系的记录。 你可以通过 Github 获取到完整的源码。 在示例数据库中，有 bookmarks（书签）表和 tags（标签）表。每个书签可以关联多个标签，反之亦然，因此 bookmarks 表和 tags 表之间存在多对多的关系。 让我们看看如何获取书签列表以及与之关联的标签 首先，创建 BookmarkWithTags record。 package com.sivalabs.bookmarks.models; import java.util.List; public record BookmarkWithTags(Long id, String title, String url, List<TagInfo> tags) { public record TagInfo (Long id, String name){} } 使用 MULTISET Value 构造器获取多对多关系 使用 jOOQ 的 MULTISET Value Constructor 来获取书签列表和标签。 实现获取书签和标签，如下： package com.sivalabs.bookmarks.repositories; import com.sivalabs.bookmarks.models.BookmarkWithTags; import org.jooq.DSLContext; import org.springframework.stereotype.Repository; import java.util.List; import static com.sivalabs.bookmarks.jooq.Tables.BOOKMARK_TAG; import static com. https://springdoc.cn/spring-boot-jooq-tutorial-fetching-one-to-many-associations/ Thu, 09 Nov 2023 11:47:54 +0800 https://springdoc.cn/spring-boot-jooq-tutorial-fetching-one-to-many-associations/ 上一教程 中介绍了如何使用 jOOQ 检索一对一（*One-to-One）关系的记录。本文将带你了解如何使用 jOOQ 检索一对多（One-to-Many）关系的记录。 你可以在 Github 获取完整的源码。 在示例数据库中，有 users（用户）表和 bookmarks（书签）表。每个用户可以创建多个书签，因此 users 表和 bookmarks 表之间是一对多的关系。 让我们看看如何获取用户详细信息以及用户创建的书签。 首先，创建 UserWithBookmarks Record。 package com.sivalabs.bookmarks.models; import java.util.List; public record UserWithBookmarks(Long id, String name, String email, List<BookmarkInfo> bookmarks) { public record BookmarkInfo (Long id, String title, String url){} } 使用 MULTISET Value 构造器获取一对多关系 使用 jOOQ 的 MULTISET Value 构造函数来获取用户创建的书签列表。有关 MULTISET Value 构造函数的更多详情，请访问：https://www.jooq.org/doc/latest/manual/sql-building/column-expressions/multiset-value-constructor/。 此外，强烈推荐你阅读《jOOQ 3.15 的新 Multiset Operator 将如何改变你对 SQL 的看法》一文。 实现获取用户详细信息以及该用户创建的书签。 @Repository public class UserRepository { . https://springdoc.cn/spring-boot-jooq-tutorial-fetching-one-to-one-associations/ Thu, 09 Nov 2023 11:08:56 +0800 https://springdoc.cn/spring-boot-jooq-tutorial-fetching-one-to-one-associations/ 上一教程 介绍了如何使用 jOOQ 实现基本的 CRUD 操作。本文将带你了解如何使用 jOOQ 检索一对一（One-to-One）关系的记录。 你可以在 Github 上找到完整的源码。 一般来说，在显示记录列表时，只会显示记录的最基本的信息，当点击记录时，才会显示记录的完整信息。 在本示例应用中，用户列表只显示 id、name 和 email 基本信息。当点击详情时，才显示包含用户偏好（Preferences）的完整信息。 更新 findUserById() 方法，以获取用户偏好设置。 首先，创建 UserPreferences record。 public record UserPreferences(Long id, String theme, String language) { } 更新 User 类，使其包含 UserPreferences。 package com.sivalabs.bookmarks.models; public record User ( Long id, String name, String email, String password, UserPreferences preferences ) { public User(Long id, String name, String email, String password) { this(id, name, email, password, null); } public static User create(Long id, String name, String email, String password) { return new User(id, name, email, password, null); } } 在 SQL 中，可以使用 LEFT OUTER JOIN 查询获取关联数据，如下所示： https://springdoc.cn/spring-boot-jooq-tutorial-crud-operations/ Thu, 09 Nov 2023 10:40:48 +0800 https://springdoc.cn/spring-boot-jooq-tutorial-crud-operations/ 在 上一教程 中，介绍了如何使用 testcontainers-jooq-codegen-maven-plugin 生成 jOOQ 代码，以及如何使用 jOOQ DSL 执行 SQL 查询。 本文将带你了解如何使用 jOOQ 对 USERS 表执行基本的 CRUD（创建、读取、更新、删除）操作。 你可以在 Github 上获取到完整的源码。 findAllUsers() 首先，从 USERS 表中获取所有用户。假设只检索 USERS 表中的 id、name、email 和 password 列。 创建 User record，如下： package com.sivalabs.bookmarks.models; public record User(Long id, String name, String email, String password) { } 在 UserRepository 类中实现 findAllUsers() 方法，如下： package com.sivalabs.bookmarks.repositories; import com.sivalabs.bookmarks.models.User; import org.jooq.DSLContext; import org.jooq.impl.SQLDataType; import org.springframework.stereotype.Repository; import java.util.List; import static com.sivalabs.bookmarks.jooq.tables.Users.USERS; import static org. https://springdoc.cn/spring-boot-jooq-tutorial-getting-started/ Thu, 09 Nov 2023 09:42:31 +0800 https://springdoc.cn/spring-boot-jooq-tutorial-getting-started/ jOOQ 是一个 Java 持久库，提供用于编写类型安全 SQL 查询的 SQL DSL。它支持大多数流行的数据库，如 MySQL、PostgreSQL、Oracle、SQL Server 等。 本文将带你了解如何在 Spring Boot 中使用 jOOQ 实现持久层。JOOQ 也可以在 Kotlin、Scala 等其他基于 JVM 的语言中使用。 本系列教程中，将带你学习如何在 Spring Boot 中使用 JOOQ 实现： 基本的 CRUD 操作 一对一关系检索 一对多关系检索 多对多关系检索 你可以在 Github 获取完整的源码。 前提条件 安装 JDK 17 或更高版本 安装任何容器运行时，如 Docker Desktop、OrbStack 等。 注意：jOOQ 不需要 Docker。只是使用 Testcontainers 进行 jOOQ 代码生成和测试需要一个容器运行时。 示例数据库 本教程使用下列示例数据库。 创建 Spring Boot 应用 使用 Spring Initializr 创建一个 Spring Boot 项目。选择 JOOQ Access Layer、Flyway Migration、PostgreSQL Driver 和 Testcontainers。 https://springdoc.cn/jwt-authentication-in-spring-microservices-jwt-token/ Wed, 08 Nov 2023 21:09:49 +0800 https://springdoc.cn/jwt-authentication-in-spring-microservices-jwt-token/ Spring Boot 微服务需要对用户进行身份认证，其中一种方式是使用 JSON Web Token （JWT）。JWT 是一种开放标准（RFC 7519），它定义了一种紧凑的机制，用于在各方之间安全地传输信息。 本文将会带你了解如何在 Spring Boot 微服务项目中使用 JWT 进行身份认证。 JWT Token 概览 JWT 的体积相对较小。因此，它可以通过 URL 发送： POST 参数 HTTP 请求头 通过 HTTP Header 发送 Token 是最常见的方式。 JWT Token 包含一个实体（可以是用户或服务）的所有必要信息。 下图显示了使用 JWT 进行身份认证的典型用例。 示例应用 创建两个服务： AuthenticatorService：负责验证用户名和密码。验证成功后，该服务会生成并返回一个 JWT Token。 BlogService：受保护的服务。该服务包含一个 Filter，用于验证客户端发送的 JWT Token。验证成功后，该服务会返回业务数据。 下图显示了客户端与上述服务之间的交互。 AuthenticatorService Maven 依赖 添加 jjwt 依赖，用于生成 JWT Token。 <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.1</version> </dependency> <!-- 其他依赖忽略 --> 实体 AuthenticatorService 包含一个 User 实体，用于表示用户凭证。如下： package com. https://springdoc.cn/spring-boot-fastjson2/ Wed, 08 Nov 2023 16:24:22 +0800 https://springdoc.cn/spring-boot-fastjson2/ Fastjson2 是 Fastjson 的一个重大升级版本。 以下摘自官方的介绍： FASTJSON 2是一个性能极致并且简单易用的Java JSON库。 FASTJSON 2是FASTJSON项目的重要升级，和FASTJSON 1相比，性能有非常大的提升，解决了autoType功能因为兼容和白名单的安全性问题。 性能极致，性能远超过其他流行 JSON 库，包括 jackson/gson/org.json，性能数据: https://github.com/alibaba/fastjson2/wiki/fastjson_benchmark 支持JDK新特性，包括JDK 11/JDK 17，针对compact string优化，支持Record，支持GraalVM Native-Image 完善的JSONPath支持，支持 SQL:2016 的 JSONPath 语法 支持Android 8+，客户端和服务器一套 API 支持Kotlin https://alibaba.github.io/fastjson2/kotlin_cn 支持JSON Schema https://alibaba.github.io/fastjson2/json_schema_cn 新增加支持二进制格式 JSONB https://alibaba.github.io/fastjson2/jsonb_format_cn 总得来说，提高了性能（拳打 Gson，脚踢 Jackson）和饱解决了饱受诟病的安全问题（因为 Fastjson 屡次爆出反序列化安全问题，在国内被戏称为 Bugjson）。 Fastjson2 确实一个款性能很高的 Json 库，API 也设计得比较简单、易用。本文将带你了解如何在 Spring 中使用 Fastjson2。 1、依赖 Fastjson2 采用 多模块 的结构设计，对 Spring 等框架的支持现独立在 extension 包中。 2.0.23 版本之后为了兼容 Spring 5.x / 6.x，将不同的版本独立出来了。 使用 Maven： <!-- Sring 5 --> <dependency> <groupId>com. https://springdoc.cn/spring-security-request-rejected-exception/ Wed, 08 Nov 2023 14:36:04 +0800 https://springdoc.cn/spring-security-request-rejected-exception/ 1、简介 Spring 5.0 至 5.0.4、4.3 至 4.3.14 以及其他旧版本在 Windows 系统上存在目录或路径遍历安全漏洞。 静态资源配置错误会导致恶意用户访问服务器的文件系统。例如，在 Windows 上使用 file: 协议配置静态资源，可能导致用户非法访问文件系统。 Spring 承认存在该 漏洞，并在后续版本中对其进行了修复。 此修复可防止应用遭受路径遍历攻击。不过，在修复后，一些之前的 URL 现在会抛出 org.springframework.security.web.firewall.RequestRejectedException 异常。 本文先带你了解什么是 “路径遍历攻击”，在这个知识背景下再带你了解 org.springframework.security.web.firewall.RequestRejectedException 和 StrictHttpFirewall 的相关知识。 2、路径遍历漏洞 路径遍历或目录遍历漏洞可非法访问 Web 文档根目录以外的内容。例如，篡改 URL 可对文档根目录以外的文件进行未经授权的访问。 虽然大多数最新和流行的 Web 服务器都能抵消大部分攻击，但攻击者仍可使用特殊字符（如 ./、../）的 URL 编码来规避 Web 服务器的安全设置并获取非法访问权限。 OWASP 介绍了路径遍历漏洞和解决方法。 3、Spring 的漏洞 先尝试复现这个漏洞，然后再介绍如何进行修复。 首先，克隆 Spring Framework MVC 示例。然后，修改 pom.xml，用一个易受攻击的版本替换现有的 Spring Framework 版本。 克隆仓库： git clone git@github.com:spring-projects/spring-mvc-showcase.git 在克隆目录中，编辑 pom.xml，修改 Spring Framework 的版本为 5.0.0.RELEASE： <org.springframework-version>5.0.0.RELEASE</org.springframework-version> 接下来，编辑 Web 配置类 WebMvcConfig，修改 addResourceHandlers 方法，使用 file: 将资源映射到本地文件目录： https://springdoc.cn/spring-boot-env-variable-prefixes/ Wed, 08 Nov 2023 10:27:09 +0800 https://springdoc.cn/spring-boot-env-variable-prefixes/ 1、概览 本文将带你了解 Spring Boot 2.5 中的一个新特性：为系统环境变量指定前缀。通过该特性，就可以在同一环境中运行多个不同的 Spring Boot 应用，只要所有属性都使用带前缀的版本。 2、环境变量前缀 有时，我们可能需要在同一个环境中运行多个 Spring Boot 应用，并且经常会面临环境变量名称分配的问题。现在，我们可以在应用级别设置一个 “前缀”，不同应用加载不同前缀的环境变量即可。 以一个简单的 Spring Boot 应用为例，通过设置前缀来修改应用属性，例如 tomcat 服务器端口。 关于 Spring Boot 中属性属性的优先级，你可以参阅 中文文档。 2.1、Spring Boot 应用示例 创建一个 Spring Boot 应用。 首先，为应用设置一个前缀。为了简单起见，称之为 prefix： @SpringBootApplication public class PrefixApplication { public static void main(String[] args) { SpringApplication application = new SpringApplication(PrefixApplication.class); // 设置环境变量前缀 application.setEnvironmentPrefix("prefix"); application.run(args); } } 不能使用已经包含下划线字符（_）的单词作为前缀。否则，抛出异常。 再创建一个 API 端点，返回应用正在监听的端口： @Controller public class PrefixController { @Autowired private Environment environment; @GetMapping("/prefix") public String getServerPortInfo(final Model model) { model. https://springdoc.cn/spring-boot-override-dependency-versions/ Wed, 08 Nov 2023 09:49:35 +0800 https://springdoc.cn/spring-boot-override-dependency-versions/ 1、简介 Spring Boot 为大多数常用的依赖、第三方库都定义好了最兼容的版本号（如 JPA、MySQL 驱动、Redis 客户端）。得益于此，我们可以快速地创建一个新应用。 但，有时出于特殊原因，我们需要修改这些预定义的依赖版本号。 2、Spring Boot 依赖清单（BOM） Spring Boot 使用 Bill of Materials (BOM) 来定义依赖和版本。 大多数 Spring Boot 项目都继承自 spring-boot-starter-parent，而 spring-boot-starter-parent 本身又继承自 spring-boot-dependencies 。后者就是 Spring Boot BOM，它只是一个 Maven POM 文件，其中有一个很大的 ependencyManagement 节点： <dependencyManagement> <dependencies> <dependency> ... </dependency> <dependency> ... </dependency> </dependencies> </dependencyManagement> 通过使用 Maven 的 dependencyManagement，BOM 可以指定依赖的默认版本（如果应用使用了这个依赖）。 Spring Boot BOM 中的一个依赖如下： <dependency> <groupId>org.apache.activemq</groupId> <artifactId>activemq-amqp</artifactId> <version>${activemq.version}</version> </dependency> 这意味着，在项目中依赖了 ActiveMQ，就会使用这个默认的版本。 另外，注意。版本是使用属性占位符指定的。这是 Spring Boot BOM 中的常见做法，它在自己的 properties 部分中提供了该属性和其他属性的值。 3、覆盖 Spring Boot 管理的依赖版本 既然已经了解了 Spring Boot 如何管理依赖版本，那就来看看如何覆盖它们。 https://springdoc.cn/ssl-hot-reload-in-spring-boot-3-2-0/ Wed, 08 Nov 2023 09:24:30 +0800 https://springdoc.cn/ssl-hot-reload-in-spring-boot-3-2-0/ Spring Boot 3.2.0 为嵌入式 Web 服务器添加了热加载 SSL 证书和密钥的功能。这意味着无需重启应用就能替换 SSL 配置。Tomcat 和 Netty 嵌入式 Web 服务器支持热重载。 首先，使用 OpenSSL 创建 SSL 私钥和匹配证书： mkdir certs cd certs openssl req -x509 -subj "/CN=demo-cert-1" -keyout demo.key -out demo.crt -sha256 -days 365 -nodes -newkey ed25519 这会创建一个私钥，存储在 certs/demo.key 中，和一个与之匹配的（自签名）证书，通用名称为 demo-cert-1，存储在 certs/demo.crt 中。 现在创建一个新的 Spring Boot 3.2.0 应用，添加 Spring Web 依赖，默认情况下使用 Tomcat Web 服务器。你可以通过 start.springboot.io 快速创建。 在 application.yaml 配置文件中，添加如下配置： spring.ssl.bundle.pem: demo: reload-on-update: true keystore: certificate: "certs/demo.crt" private-key: "certs/demo.key" 这配置了一个 SSL Bundle，名称为 demo，并配置上文生成的证书和私钥。 https://springdoc.cn/spring-boot-static-file-garbled/ Tue, 07 Nov 2023 16:07:35 +0800 https://springdoc.cn/spring-boot-static-file-garbled/ 通过浏览器直接访问 Spring Boot 中的静态文件（如 js、css），如果静态文件包含中文的话则会显示乱码。 静态文件 在 src/main/resources/public 目录下创建一个 test.js 文件，用于测试： public 目录是 Spring Boot 默认的静态资源目录，里面的文件可以被客户端直接访问。 test.js 文件内容如下： // 输出中文内容 (function(){ console.log("你好 Spring Doc"); })(); 这个文件中包含两段中文内容。 测试 启动应用，打开浏览器访问上述 JS 文件：http://localhost:8080/test.js。 如你所见，文件中的中文内容全部乱码。尽管这个 js 文件本身就是 UTF-8 编码。 解决办法 究其原因，是因为服务器响应的 Content-Type: application/javascript 头中没有指定文本文件的编码类型。 我们可以在配置文件中对编码类型进行设置： server: servlet: encoding: force: true server.servlet.encoding.force 配置指定了是否在 HTTP 请求和响应中强制使用配置的字符集编码。默认为 false，这里设置为 true。 字符集编码可以通过 server.servlet.encoding.charset 属性进行配置，它默认就是 UTF-8。 重启应用，再次访问 test.js 文件： Content-Type Header 指定了正确的编码，文件中的中文内容已经正常显示了。 https://springdoc.cn/spring-boot-actuator-startup/ Tue, 07 Nov 2023 14:32:37 +0800 https://springdoc.cn/spring-boot-actuator-startup/ 1、概览 Spring Boot 的启动过程可能涉及到繁琐的资源初始化。本文将带你了解如何通过 Spring Boot Actuator 的 Startup 端点追踪和监控这些启动信息。 2、应用启动追踪 追踪应用启动过程中的各个步骤可以提供有用的信息，帮助我们了解应用启动各个阶段所花费的时间。这种工具还能提高我们对上下文生命周期和应用启动顺序的理解。 Spring 提供了 记录应用启动 功能。此外，Spring Boot Actuator 还通过 HTTP 或 JMX 提供了多种生产级监控和管理功能。 从 Spring Boot 2.4 开始，应用启动追踪指标可通过 /actuator/startup 端点获得。 3、设置 在 pom.xml 中添加 spring-boot-starter-actuator 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> 还需要 spring-boot-starter-web 依赖项，用于暴露 HTTP 端点： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.5.4</version> </dependency> 在 application.properties 文件中配置属性，在 HTTP 上公开所需的端点： management.endpoints.web.exposure.include=startup 最后，使用 curl 查询 Actuator 的 HTTP 端点，使用 jq 解析 JSON 响应。 4、Actuator 端点 为了捕获启动事件，需要使用 @ApplicationStartup 接口的实现来配置应用。默认情况下，管理应用生命周期的 ApplicationContext 使用 “空” 操作的实现。这显然不会执行启动检测和追踪，从而将开销降至最低。 https://springdoc.cn/spring-onceperrequestfilter/ Tue, 07 Nov 2023 10:32:41 +0800 https://springdoc.cn/spring-onceperrequestfilter/ 1、概览 本文将带你了解 Spring 中一种特殊类型的 Filter（过滤器）OncePerRequestFilter。 通过实例了解它的功能和用法。 2、OncePerRequestFilter 是什么？ 回顾一下 Filter 的工作原理。Filter 可以在 Servlet 执行之前或之后调用。当请求被调度给一个 Servlet 时，RequestDispatcher 可能会将其转发给另一个 Servlet。另一个 Servlet 也有可能使用相同的 Filter。在这种情况下，同一个 Filter 会被调用多次。 但是，有时需要确保每个请求只调用一次特定的 Filter。一个常见的用例是在使用 Spring Security 时。当请求通过过滤器链（Filter Chain）时，对请求的身份证认证应该只执行一次。 在这种情况下，可以继承 OncePerRequestFilter。Spring 保证 OncePerRequestFilter 只对指定请求执行一次。 3、使用 OncePerRequestFilter 处理同步请求 定义一个继承了 OncePerRequestFilter 的 AuthenticationFilter Filter 类，并覆写 doFilterInternal() 方法： public class AuthenticationFilter extends OncePerRequestFilter { @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { String usrName = request.getHeader(“userName”); logger.info("Successfully authenticated user " + userName); filterChain. https://springdoc.cn/spring-webflux-cacheable/ Tue, 07 Nov 2023 09:58:24 +0800 https://springdoc.cn/spring-webflux-cacheable/ 1、概览 本文将带你了解如何在 Spring WebFlux 中使用 @Cacheable 注解实现缓存，以及一些常见的问题和解决办法。 2、@Cacheable 和响应式类型 在本文撰稿时，@Cacheable 还不能和响应式框架无缝整合。主要问题在于，目前还没有非阻塞式的缓存实现（JSR-107 缓存 API 是阻塞式的）。只有 Redis 提供了响应式驱动。 虽然，仍然可以在方法上使用 @Cacheable。这会缓存封装对象（Mono 或 Flux），但不会缓存方法的实际结果。 2.1、项目设置 创建一个使用响应式 MongoDB 驱动的 Spring WebFlux 项目。并且用 Testcontainers 代替真实运行的 MongoDB 进行测试。 测试类使用 @SpringBootTest 进行注解，如下： final static MongoDBContainer mongoDBContainer = new MongoDBContainer(DockerImageName.parse("mongo:4.0.10")); @DynamicPropertySource static void mongoDbProperties(DynamicPropertyRegistry registry) { mongoDBContainer.start(); registry.add("spring.data.mongodb.uri", mongoDBContainer::getReplicaSetUrl); } 这几行代码会启动 MongoDB 实例，并将 URI 传递给 Spring Boot 以自动配置 Mongo Repository。 创建带有保存和获取 Item 方法的 ItemService 类： @Service public class ItemService { private final ItemRepository repository; public ItemService(ItemRepository repository) { this. https://springdoc.cn/spring-415-unsupported-mediatype/ Tue, 07 Nov 2023 09:12:21 +0800 https://springdoc.cn/spring-415-unsupported-mediatype/ 1、概览 本文将带你了解如何解决在 Spring Boot API 返回状态码 “415 Unsupported MediaType” 的问题，以及出现该问题的原因。 2、背景 我们一个老客户要求我们给他的系统再开发一个桌面应用，类似于用户管理。新的桌面应用，直接调用原系统的 API 服务。 3、API 请求 通过 API 来获取所有用户： curl -X GET https://baeldung.service.com/user 成功获取响应。接着，获取一个单独的用户： curl -X GET https://baeldung.service.com/user/{user-id} 响应如下： { "id": 1, "name": "Jason", "age": 23, "address": "14th Street" } 一切也OK，根据响应，可以确定用户拥有以下参数：id、name、age 和 address。 现在，尝试添加新用户： curl -X POST -d '{"name":"Abdullah", "age":28, "address":"Apartment 2201"}' https://baeldung.service.com/user/ 结果，这次服务器响应了 HTTP 状态码为 415 的错误响应： { "timestamp": "yyyy-MM-ddThh:mm:ss.SSS+00:00", "status": 415, "error": "Unsupported Media Type", "path": "/user/" } 在弄清 “为什么会出现这个错误？” 之前，需要先弄清楚 “这个错误是什么？”。 https://springdoc.cn/spring-boot-jsp/ Mon, 06 Nov 2023 20:02:03 +0800 https://springdoc.cn/spring-boot-jsp/ 在前后端分离架构、SPA 应用大行其道的今天，模板引擎已经逐渐被淘汰了。更别提 JSP 这种上古模板引擎了。 Spring Boot 推荐使用 FreeMarker、Groovy、Thymeleaf 或者 Mustache 作为模板引擎。不推荐 JSP，主要是 JSP 的编译方式比价特殊，它需要先把 JSP 代码编译为 Servlet，最后通过执行 Servlet 来输出模板内容。 当然，在 Spring Boot 中使用 JSP 也是可以的，只需要些许配置即可。 创建 Spring Boot 项目 创建 Spring Boot（3.0.3）项目，在 pom.xml 中添加如下依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- Servlet --> <dependency> <groupId>jakarta.servlet</groupId> <artifactId>jakarta.servlet-api</artifactId> </dependency> <!-- Tomcat 嵌入式 JSP 解析器 --> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> </dependency> <!-- JSP jstl --> <dependency> <groupId>javax.servlet.jsp.jstl</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> 注意，jstl 需要自己手动添加版本号，它没有被 Spring Boot 管理。 在 Spring Boot 支持的嵌入式容器中只有 Tomcat 支持使用 JSP，Undertow 和 Jetty 均不支持！ https://springdoc.cn/spring-conditionalonthreading/ Mon, 06 Nov 2023 19:18:48 +0800 https://springdoc.cn/spring-conditionalonthreading/ 1、简介 本文将带你了解一个相对较新的 Spring Boot 条件注解 @ConditionalOnThreading。 2、条件注解 条件注解提供了一种仅在满足各种特定条件时才在 BeanFactory 中注册 Bean 的方法。开发人员通过使用 Condition 接口为每个注解单独定义这些条件。 Spring Boot 为常见用例提供了大量预定义的条件注解。常见的示例有 @ConditionalOnProperty、@ConditionalOnBean 和 @ConditionalOnClass。 3、@ConditionalOnThreading 原理 @ConditionalOnThreading 只是 Spring Boot 中另一个预定义的条件注解。它是在 3.2 版本中添加的，在本文撰稿时，该版本本身还是候选发布版。也就是说，需要使用专用的 Spring Artifacts 仓库。 <repositories> <repository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/milestone</url> <snapshots> <enabled>false</enabled> </snapshots> </repository> <repository> <id>spring-snapshots</id> <name>Spring Snapshots</name> <url>https://repo.spring.io/snapshot</url> <releases> <enabled>false</enabled> </releases> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/milestone</url> <snapshots> <enabled>false</enabled> </snapshots> </pluginRepository> <pluginRepository> <id>spring-snapshots</id> <name>Spring Snapshots</name> <url>https://repo.spring.io/snapshot</url> <releases> <enabled>false</enabled> </releases> </pluginRepository> </pluginRepositories> @ConditionalOnThreading 注解仅允许在 Spring 内部配置为使用特定类型的线程时创建 Bean。所谓线程类型，是指平台线程或虚拟线程。回顾一下，从 Java 21 开始，我们就可以 使用虚拟线程来代替平台线程 了。 https://springdoc.cn/rest-localized-validation-messages/ Mon, 06 Nov 2023 13:26:44 +0800 https://springdoc.cn/rest-localized-validation-messages/ 1、概览 在 Web 应用中，我们通常需要通过 spring-validation 对客户端提交的数据进行校验。如果校验失败则会抛出异常。默认情况下，关于校验失败细节的异常信息是英文。本文将会带你了解如何对校验失败时的异常消息进行国际化（也称为“本地化”）。 2、依赖 首先在 pom.xml 中添加 Spring Boot Starter Web 和 Spring Boot Starter Validation： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validation</artifactId> </dependency> 最新版本可在 Maven Central 上找到。 3、本地化信息存储 在 Java 应用中，通常使用 properties 文件存储本地化信息。一般称为 Resource Bundle。 这些文件是由键值对组成的纯文本文件。key 是信息检索的标识符，而对应的 value 则是相应语言的本地化消息。 接下来，我们创建 2 个 properties 文件。 CustomValidationMessages.properties 是默认的 properties 文件，文件名不包含任何语言名称。只要客户端指定的语言不支持，应用就会使用默认语言： field.personalEmail=Personal Email validation.notEmpty={field} cannot be empty validation.email.notEmpty=Email cannot be empty 再创建一个额外的中文语言的 properties 文件 - CustomValidationMessages_zh.properties。只要客户端指定 zh 或 zh-tw 等变体作为本地语言，应用语言就会切换为中文： https://springdoc.cn/spring-boot-kafka-streams/ Mon, 06 Nov 2023 10:32:44 +0800 https://springdoc.cn/spring-boot-kafka-streams/ 1、简介 流式数据在现实生活中的一些例子包括传感器数据、股票市场事件流和系统日志。在本文中，我们通过构建一个简单的字数统计流式应用来介绍如何在 Spring Boot 中使用 Kafka Streams。 2、概览 Kafka Streams 在 Kafka Topic 和关系型数据库表之间提供了一种对偶性。它使我们能够对一个或多个流式事件进行连接、分组、聚合和过滤等操作。 Kafka 流的一个重要概念是处理器拓扑（Processor Topology）。处理器拓扑是 Kafka Stream 对一个或多个事件流进行操作的蓝图。从本质上讲，处理器拓扑可视为有向无环图。在这个图中，节点分为源节点、处理器节点和汇节点，而边则代表流事件的流向。 位于拓扑结构顶端的源接收来自 Kafka 的流数据，将其向下传递到执行自定义操作的处理器节点，并通过汇节点流出到新的 Kafka Topicc。在进行核心处理的同时，还利用检查点（Checkpoint）定期保存数据流的状态，以实现容错和弹性。 3、依赖 首先在 POM 中添加 spring-kafka 和 kafka-streams 依赖： <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>2.7.8</version> </dependency> <dependency> <groupId>org.apache.kafka</groupId <artifactId>kafka-streams</artifactId> <version>2.7.1</version> </dependency> 4、示例 示例应用从输入的 Kafka Topic 中读取流式事件。读取记录后，它会对记录进行处理，分割文本并计算单个字数。随后，它将更新的字数发送到 Kafka 输出。除了输出 Topic 外，还要创建一个简单的 REST 服务，通过 HTTP 端点公开该计数。 总之，输出 Topic 将不断更新从输入事件中提取的单词及其更新计数。 4.1、配置 在 Java 配置类中定义 Kafka Stream 配置： @Configuration @EnableKafka @EnableKafkaStreams public class KafkaConfig { @Value(value = "${spring. https://springdoc.cn/spring-boot-startup-speed/ Mon, 06 Nov 2023 09:37:34 +0800 https://springdoc.cn/spring-boot-startup-speed/ 1、简介 本文将带你了解如何通过调整 Spring 应用的配置、JVM 参数和使用 GraalVM 原生镜像来缩短 Spring Boot 的启动时间。 2、调整 Spring 应用 首先，创建一个 Spring Boot（2.5.4）应用，添加 Spring Web、Spring Actuator 和 Spring Security 依赖。 还要添加 spring-boot-maven-plugin 插件，并配置将应用打包到 jar 文件中： <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>${spring-boot.version}</version> <configuration> <finalName>springStartupApp</finalName> <mainClass>com.baeldung.springStart.SpringStartApplication</mainClass> </configuration> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> 使用标准的 java -jar 命令运行 jar 文件，并查看应用的启动时间。 c.b.springStart.SpringStartApplication : Started SpringStartApplication in 3.403 seconds (JVM running for 3.961) 如上，应用启动时间约为 3.4 秒。我们把这个时间作为下文调整的参考。 2.1、延迟初始化 Spring 支持延迟初始化。延迟初始化意味着 Spring 不会在启动时创建所有 Bean。此外，Spring 在需要 Bean 之前不会注入任何依赖。从 Spring Boot 2. https://springdoc.cn/spring-boot-read-and-write-datasource/ Sun, 05 Nov 2023 14:23:49 +0800 https://springdoc.cn/spring-boot-read-and-write-datasource/ 前言 现在的 Web 应用大都是读多写少。除了缓存以外还可以通过数据库 “主从复制” 架构，把读请求路由到从数据库节点上，实现读写分离，从而大大提高应用的吞吐量。 通常，我们在 Spring Boot 中只会用到一个数据源，即通过 spring.datasource 进行配置。前文 《在 Spring Boot 中配置和使用多个数据源》 介绍了一种在 Spring Boot 中定义、使用多个数据源的方式。但是这种方式对于实现 “读写分离” 的场景不太适合。首先，多个数据源都是通过 @Bean 定义的，当需要新增额外的从数据库时需要改动代码，非常不够灵活。其次，在业务层中，如果需要根据读、写场景切换不同数据源的话只能手动进行。 对于 Spring Boot “读写分离” 架构下的的多数据源，我们需要实现如下需求： 可以通过配置文件新增数据库（从库），而不不需要修改代码。 自动根据场景切换读、写数据源，对业务层是透明的。 幸运的是，Spring Jdbc 模块类提供了一个 AbstractRoutingDataSource 抽象类可以实现我们的需求。 它本身也实现了 DataSource 接口，表示一个 “可路由” 的数据源。 核心的代码如下： public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean { // 维护的所有数据源 @Nullable private Map<Object, DataSource> resolvedDataSources; // 默认的数据源 @Nullable private DataSource resolvedDefaultDataSource; // 获取 Jdbc 连接 @Override public Connection getConnection() throws SQLException { return determineTargetDataSource(). https://springdoc.cn/spring-security-csp/ Sun, 05 Nov 2023 12:52:01 +0800 https://springdoc.cn/spring-security-csp/ 1、概览 跨站脚本攻击（Cross-Site Scripting，XSS）一直稳居最常见的 十大网络攻击 之列。XSS 攻击发生在 Web 服务器处理用户恶意输入时，未经验证或编码即在页面上渲染。与 XSS 攻击类似，代码注入和点击劫持通过窃取用户数据和冒充用户身份来对 Web 应用造成严重影响。 本文将会带你了解如何使用 Spring Security 通过内容安全策略（Content-Security-Policy）保护 Web 应用免受点击劫持、代码注入和 XSS 攻击。 2、Content Security Policy 内容安全策略（Content Security Policy，简称 CSP）是一种 HTTP 响应头，可大大减少 现代浏览器 中的代码注入攻击，如 XSS、点击劫持 等。 Web 服务器通过 Content-Security-Policy Header 部指定了浏览器可以渲染的资源的列表。这些资源可以是浏览器渲染的任何内容，例如 CSS、JavaScript、图像等。 该 Header 的语法如下： Content-Security-Policy: <directive>; <directive>; <directive> ; ... 此外，还可以将此策略设置为 HTML 页面中 <meta> 标签的一部分： <meta http-equiv="Content-Security-Policy" content="<directive>;<directive>;<directive>; ..."> 每个 指令 都包含一个具有多个值的 key。指令可以不止一个，每个指令之间用分号（;） 分隔： Content-Security-Policy: script-src 'self' https://baeldung.com; style-src 'self'; 如上例所示，有两个指令（script-src 和 style-src），而指令 script-src 有两个值（self 和 https://baeldung. https://springdoc.cn/spring-cloud-load-balancer/ Sun, 05 Nov 2023 11:40:58 +0800 https://springdoc.cn/spring-cloud-load-balancer/ 1、简介 随着微服务架构越来越流行，在不同服务器上运行多个服务变得越来越普遍。本文将带你了解如何使用 Spring Cloud Load Balancer（负载均衡器） 创建容错性更强的应用。 2、负载均衡是什么？ 负载均衡是在同一应用的不同实例之间分配流量的过程。 为了容错，每个应用通常都要运行多个实例。因此，当一个服务需要与另一个服务通信时，它需要选择一个特定的实例来发送请求。 负载均衡，有很多算法： 随机选择：随机选择一个实例 循环：每次按相同顺序选择实例 最少连接：选择当前连接最少的实例 权重指标：使用权重指标选择最佳实例（例如 CPU 或内存使用率） IP 哈希（Hash）：使用客户端 IP 的哈希值映射到实例 以上只是负载均衡算法的几个例子，每种算法都有其优缺点。 随机选择和轮循很容易实现，但可能无法优化服务的使用。相反，最少连接和权重指标比较复杂，但通常能创造更优化的服务利用率。IP 哈希可以保证客户端每次都命中同一台实例，意味着实例可以保存一些客户端的状态信息，但它的容错性不强。 3、Spring Cloud Load Balancer 简介 Spring Cloud Load Balancer 用来创建以负载均衡方式与其他应用通信的应用。可以使用任意算法，在进行远程服务调用时轻松实现负载均衡。 接下来，我们通过实例来进行说明。首先，创建一个简单的服务器应用。服务器只有一个 HTTP 端点，可以作为多个实例运行。 然后，创建一个客户端应用，使用 Spring Cloud Load Balancer 在服务器的不同实例之间轮流发送请求。 3.1、示例服务器 创建一个简单的 Spring Boot 应用： @SpringBootApplication @RestController public class ServerApplication { public static void main(String[] args) { SpringApplication.run(ServerApplication.class, args); } @Value("${server.instance.id}") String instanceId; @GetMapping("/hello") public String hello() { return String. https://springdoc.cn/spring-junit-failed-to-load-applicationcontext/ Sun, 05 Nov 2023 10:55:00 +0800 https://springdoc.cn/spring-junit-failed-to-load-applicationcontext/ 1、概览 在 Spring Boot 应用中，可以同时包含基于注解和基于 XML 的配置来混合定义 Bean。在这种环境中，如果你在测试类中使用基于 XML 的配置可能会遇到 “Failed to load ApplicationContext” 异常。因为 Application Context 没有加载到 Test Context 中。 本文将会带你了解如何把 XML Application Context 集成到 Spring Boot 应用的测试中。 2、“Failed to load ApplicationContext” 异常 在 Spring Boot 应用中集成基于 XML 的 Application Context 来重现该异常。 首先，假设有一个包含 Service Bean 定义的 application-context.xml 文件： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="employeeServiceImpl" class="com.baeldung.xmlapplicationcontext.service.EmployeeServiceImpl" /> </beans> 在 webapp/WEB-INF/ 位置添加 application-context.xml 文件： 再创建一个 Service 接口和实现类： https://springdoc.cn/spring-cloud-gateway-oauth2/ Sun, 05 Nov 2023 09:27:42 +0800 https://springdoc.cn/spring-cloud-gateway-oauth2/ 1、概览 Spring Cloud Gateway 是一个响应式的轻量级网关，是 Spring Cloud 体系中一个比较重要的组件。本文将带你了解如何在其基础上快速实现 OAuth 2.0 认证、授权。 2、OAuth 2.0 快速回顾 OAuth 2.0 标准是一个成熟的标准，在互联网上广泛使用，是用户和应用安全访问资源的一种安全机制。 其中涉及的关键术语如下： Resource（资源）：只有经过授权的客户端才能检索的任何类型的信息。 Client（客户端）：消费资源的应用，通常通过 REST API 消费资源。 Resource Server（资源服务器）：负责向授权客户端提供资源的服务。 Resource Owner（资源所有者）：实体（人或应用），拥有资源，并最终负责向客户端授予对该资源的访问权限。 Token（令牌）：客户端获取的一段信息，并作为请求的一部分发送给资源服务器以进行身份验证。 Identity Provider（身份提供商，即 IDP）：验证用户凭证并向客户端发放 Access Token。 Authentication Flow（认证模式/流程）：客户端获得有效 Token 必须经过的一系列步骤。 你可以通过 Auth0 的相关文档了解更多详细内容。 3、OAuth 2.0 模式 Spring Cloud Gateway 主要用于以下用途之一： OAuth Client（客户端） OAuth Resource Server（资源服务器） 我们来逐个了解。 3.1、Spring Cloud Gateway 作为 OAuth 2.0 客户端 在这种情况下，任何未经身份认证的传入请求都将触发授权码流程。一旦网关获取到 Token，它将在向后端服务发起请求时使用该 Token。 在实际应用中，一个很好的例子是聚合了 “社交应用” 的应用：对于每个支持的社交应用，网关将充当 OAuth 2.0 客户端。 因此，前端（通常是使用 Angular、React 或类似 UI 框架构建的 SPA 应用）可以代表终端户无缝访问这些应用上的数据。更重要的是：用户无需暴露自己的凭证。 https://springdoc.cn/spring-swagger-remove-error-controller/ Sat, 04 Nov 2023 14:57:36 +0800 https://springdoc.cn/spring-swagger-remove-error-controller/ 1、概览 本文将带你了解如何 Swagger 文档界面中隐藏 BasicErrorController。 3、问题 如果应用中包含了一个 BasicErrorController，Swagger 默认会将其所有端点也包含在生成的文档中。 我们需要提供自定义配置来移除不需要的 Controller。 例如，项目中的 Rest Controller 如下： @RestController @RequestMapping("good-path") public class RegularRestController { @ApiOperation(value = "This method is used to get the author name.") @GetMapping("/getAuthor") public String getAuthor() { return "Name Surname"; } } 另外，还包含一个继承 BasicErrorController 的 Error Controller： @Component @RequestMapping("my-error-controller") public class MyErrorController extends BasicErrorController { // basic constructor } 启动应用，访问文档！你可以看到，my-error-controller 包含在生成的文档中： 4、解决办法 有四种方式可以从 Swagger 文档中排除资源。 4.1、通过 basePackage() 方法排除 通过指定 Controller 所在的包，可以排除其他不需要的资源。 https://springdoc.cn/spring-cloud-sleuth-get-trace-id/ Sat, 04 Nov 2023 14:12:50 +0800 https://springdoc.cn/spring-cloud-sleuth-get-trace-id/ 1、概览 本文将带你了解 Spring Cloud Sleuth，以及如何在 Spring Boot 中使用它进行链路追踪。 它可以在日志中添加额外有用的信息，并通过唯一链路 ID 帮助 Debug。这些操作在 Sleuth 术语中称为追踪（Trace）。它们可以由多个步骤组成，称为 Span。 例如，链路追踪可以是一个从应用中查询数据的 GET 请求。当应用处理该请求时，可以将其分割成更小的步骤：用户授权、执行数据库查询、转换响应。每个步骤都是属于同一链路追踪的唯一 Span。 在某些情况下，我们可能需要获取当前 Trace 或 Span 的 ID。例如，当发生事故时，我们可以将这些信息发送给开发团队。然后，他们就可以用它来调试和解决问题。 2、应用设置 创建一个 Spring Boot 项目，并添加 spring-cloud-starter-sleuth dependency 依赖： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-sleuth</artifactId> <version>3.1.0</version> </dependency> 此 Starter 可与 Spring Boot 完美集成，并提供 Spring Cloud Sleuth 开箱即用的配置。 接下来，在 application.properties 文件中设置应用名称，这样就能在日志中看到该名称以及 Trace 和 Span ID： spring.application.name=Baeldung Sleuth Tutorial 现在，创建一个 REST Controller，提供一个 GET 端点： @RestController public class SleuthTraceIdController { @GetMapping("/traceid") public String getSleuthTraceId() { return "Hello from Sleuth"; } } 启动应用后访问这个 API 端点 http://localhost:8080/traceid，你可以看到响应：Hello from Sleuth。 https://springdoc.cn/zuul-customize-exception/ Sat, 04 Nov 2023 10:35:56 +0800 https://springdoc.cn/zuul-customize-exception/ 1、概览 Zuul 是 Netflix 推出的基于 JVM 的网关和服务器端负载均衡器。Zuul 的规则引擎提供了灵活性，可以编写规则和过滤器（Filter）来增强在 Spring Cloud 微服务架构中的路由功能。。 本文将会带你了解如何通过自定义 Error Filter 来自定义 Zuul 中的异常和 Error 响应。当代码执行过程中发生错误时，这些自定义 Error Filter 将被执行。 2、Zuul 异常 Zuul 中处理的所有异常都是 ZuulException。 ZuulException 不能通过 @ControllerAdvice 捕获，也不能通过 @ExceptionHandling 对方法进行注解。这是因为 ZuulException 是由 Error Filter 抛出的。因此，它会跳过后续的过滤链，永远不会到达 Error Controller。下图描述了 Zuul 中错误处理的层次结构： 出现 ZuulException 时，Zuul 会显示以下错误响应： { "timestamp": "2022-01-23T22:43:43.126+00:00", "status": 500, "error": "Internal Server Error" } 在某些情况下，可能需要自定义 ZuulException 响应中的错误信息或状态码。这时，Zuul Filter 就能派上用场了。 3、自定义 Zuul 异常 spring-cloud-starter-netflix-zuul Starter 包括三种 Filter：Pre（前置）、Post（后置）和 Error（错误）。 本文重点深入了解 Error Filter。 https://springdoc.cn/spring-no-converter-with-preset/ Sat, 04 Nov 2023 09:53:16 +0800 https://springdoc.cn/spring-no-converter-with-preset/ 1、概览 本文将带你了解 “HttpMessageNotWritableException: no converter for [class …] with preset Content-Type” 异常的原因以及解决办法。 2、原因 异常的堆栈信息说明了一切：Spring 找不到合适的 HttpMessageConverter，无法将 Java 对象转换为 HTTP 响应。 Spring 依靠客户端的 Accept Header 来检测它需要响应的媒体类型（Media Type）。 因此，使用未预注册消息转换器（Message Converter）的 Media Type 将导致 Spring 抛出异常。 3、重现异常 通过一个实际例子来重现异常。 创建一个 Handler Method，指定一种媒体 Media Type（用于响应），这种类型没有注册 HttpMessageConverter。 例如，使用 MediaType.APPLICATION_XML_VALUE 或字符串 application/xml： @GetMapping(value = "/student/v3/{id}", produces = MediaType.APPLICATION_XML_VALUE) public ResponseEntity<Student> getV3(@PathVariable("id") int id) { return ResponseEntity.ok(new Student(id, "Robert", "Miller", "BB")); } 接着，使用 cURL 对 http://localhost:8080/api/student/v3/1 发起请求： curl http://localhost:8080/api/student/v3/1 端点响应如下： https://springdoc.cn/spring-boot-configure-multiple-datasources/ Sat, 04 Nov 2023 09:12:34 +0800 https://springdoc.cn/spring-boot-configure-multiple-datasources/ 1、概览 一般的 Spring Boot 应用通常只需要配置一个数据库，但是有时也可能需要访问多个数据源。本文将带你了解如何在 Spring Boot 中配置和使用多个数据源。 2、默认行为 通常，我们会在 application.yml 中声明 Spring Boot 数据源，如下： spring: datasource: url: ... username: ... password: ... driverClassname: ... Spring 会将这些配置映射到 org.springframework.boot.autoconfigure.jdbc.DataSourceProperties 的实例。 DataSourceProperties 的定义如下： @ConfigurationProperties(prefix = "spring.datasource") public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean { // ... /** * Fully qualified name of the JDBC driver. Auto-detected based on the URL by default. */ private String driverClassName; /** * JDBC URL of the database. */ private String url; /** * Login username of the database. https://springdoc.cn/spring-boot-email/ Fri, 03 Nov 2023 14:44:21 +0800 https://springdoc.cn/spring-boot-email/ Spring Boot 对于发送邮件这种常用功能也提供了开箱即用的 Starter：spring-boot-starter-mail。 通过这个 starter，只需要简单的几行配置就可以在 Spring Boot 中实现邮件发送，可用于发送验证码、账户激活等等业务场景。 本文将通过实际的案例带你了解如何在 Spring Boot 中使用 QQ 邮箱发送邮件。 关于 Spring 对邮件支持的更多细节，你可以参阅 中文文档。 创建 Spring Boot 应用 在 pom.xml 中添加 spring-boot-starter-mail 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-mail</artifactId> </dependency> 属性配置 在 application.yaml 中配置属性。 spring: mail: # 指定邮件服务器地址 host: smtp.qq.com # 登录账户 username: 747692844@qq.com # 登录密码 password: "<你的密码/授权码>" # 端口 port: 465 # 默认编码 default-encoding: UTF-8 # 使用的协议 protocol: smtps # 其他的属性 properties: "mail.smtp.connectiontimeout": 5000 "mail.smtp.timeout": 3000 "mail.smtp.writetimeout": 5000 "mail. https://springdoc.cn/spring-cloud-config-without-git/ Fri, 03 Nov 2023 12:57:02 +0800 https://springdoc.cn/spring-cloud-config-without-git/ 1、简介 Spring Cloud Config 是 Spring Cloud 生态下的一个子项目，可让 Spring 应用轻松实现配置外部化。通过它，可以将配置数据作为服务暴露出来，从而使得任何具有 HTTP 客户端的应用都可以轻松地获取配置数据。 本文将会带你了解如何在 Spring Cloud Config 中使用 Git 以外的配置源来存储配置信息。 2、Spring Cloud Config 概览 Spring Cloud Config 采用了典型的客户端-服务器模型。集中式服务器（或多个服务器）从外部数据源读取配置数据。这些服务器会暴露各种 HTTP 端点，允许任何其他应用查询配置数据。 Spring Cloud Config 还能让 Spring Boot 应用非常方便地自动连接到配置服务器。服务器提供的配置数据可以像客户端应用中的其他属性源一样使用。 3、GIT Spring Cloud Config 最常见的使用案例是在 git 仓库中存储配置数据。这种方式的设置有几个优点： 灵活性：git 仓库可以容纳各种类型的文件，包括二进制文件。 安全性：可轻松控制细粒度的读写权限。 审计：强大的历史跟踪功能可轻松审核配置更改。 标准化：无论哪家提供商（Provider），Git 操作都是标准的，这意味着我们可以自行托管或使用任意数量的第三方提供商。 分布式： Git 从一开始就是为分布式设计的，因此非常适合云原生和微服务架构。 尽管有上述种种好处，但 git 并不总是存储配置数据的最佳选择。例如，项目可能已经将配置数据放在其他数据存储（如关系型数据库）中。在这种情况下，将其迁移到 git 可能就得不偿失了。 4、使用 GIT 以外的 配置源 在 Spring Cloud Config 中使用 git 以外的其他配置源时时，指的其实是服务器组件。对数据存储的选择不会影响客户端组件。只有服务器会受到影响。 在 Spring Cloud Config Server 库中，有一个名为 EnvironmentRepository 的接口定义了一个配置源。所有配置源（包括 git 和其他配置源）都必须实现该接口。 https://springdoc.cn/spring-cloud-feign-oauth-token/ Fri, 03 Nov 2023 10:45:27 +0800 https://springdoc.cn/spring-cloud-feign-oauth-token/ 1、概览 OpenFeign 是一个可以在 Spring Boot 中使用的声明式 REST 客户端。 假如想通过 OpenFeign 来调用使用 OAuth2 的 REST API，那么就需要给 OpenFeign 设置 Access Token。 本文将会带你了解如何为 OpenFeign 客户端添加 OAuth2 支持。 2、服务之间的认证 服务之间的认证 API 安全中的一个热门话题。我们可以使用 mTLS 或 JWT 为 REST API 提供认证机制。不过，OAuth2 协议是保护 API 的事实解决方案。假设我们想使用另一个服务（客户端）调用一个受保护的服务（服务器）。在这种情况下，使用 “客户端凭证（client credential）” 授权方式。这种授权方式通常用于在两个没有终端用户的 API 或系统之间进行身份认证。 下图显示了这种授权模式中的的主要角色关系： 在客户端凭证模式中，客户端通过 Token Endpoint 从授权服务器（Authorization Server）获取 Access Token。然后，客户端使用 Access Token 访问源服务器（Resource Server）上受资保护的资源。资源服务器会验证 Access Token，如果有效，则为请求提供服务。 2.1、授权服务器 创建一个授权服务器来发放 Access Token。为了方便，我们在 Spring Boot 中使用嵌入式 Keycloak。假设我们使用 GitHub 上的 授权服务器 项目。 首先，在嵌入式 Keycloak 服务器的 realm 管理中定义 Payment-app 客户端： https://springdoc.cn/swagger-enum/ Fri, 03 Nov 2023 09:53:33 +0800 https://springdoc.cn/swagger-enum/ 1、概览 本文将带你了解如何使用 swagger-maven-plugin 来在 Swagger 中记录枚举，并在 Swagger 编辑器中验证生成的 JSON 文档。 2、Swagger 是啥？ Swagger 是一种开源工具，用于定义基于 REST 的 API。在当今世界，大多数组织都在向微服务和 API 优先的方向发展。Swagger 在设计和记录 API 方面非常方便。它还提供了 Swagger 编辑器、Swagger UI 和 Swagger CodeGen 等各种工具来协助 API 开发。 此外，Swagger 是 OpenAPI 规范或 OAS 的一种实现，OAS 定义了一套用于开发 REST API 的标准，有助于全球各地的组织将编写 API 的过程标准化。 我们应用生成的 JSON 文件也将遵循 OpenAPI 规范。 在 Swagger 中使用 Enum 是个有必要的，有些 API 需要用户只能使用一组特定的预定义值。这些预定义的常量值被称为枚举（Enum）。同样，当 Swagger 公开 API 时，需要要确保用户从这组预定义值中选择一个值，而不是任意的值。 换句话说，需要在 swagger.json 文件中记录枚举，让用户知道可选的选项。 3、实现 实现一个 POST API，用于为组织招聘特定角色的员工（Employee）。角色只能是以下角色之一：Engineer、Clerk、Driver 或 Janitor。 创建 Role 枚举，其中包含 Employee 角色的所有可能值，然后创建一个 Employee 类，将角色作为其属性之一。 https://springdoc.cn/spring-data-jpa-locking/ Fri, 03 Nov 2023 09:30:27 +0800 https://springdoc.cn/spring-data-jpa-locking/ 简介 本文将会带你了解 Spring Data JPA 对锁的支持，以及如何在检索时使用共享锁或者独占锁。 JPA LockModeType JPA 提供了几种加锁的选项，可以在获取实体时通过 LockModeType 枚举来指定。 如下： LockModeType.PESSIMISTIC_READ 可对相关表记录加共享锁或读锁。 LockModeType.PESSIMISTIC_WRITE 可对相关表记录加速独占锁或写锁。 如果底层数据库不支持共享锁，那么 PESSIMISTIC_READ 策略将退回到 PESSIMISTIC_WRITE，因为该选项已被广泛支持。 根据 ID 获取实体时加锁 JPA EntityManager 提供了一个 find 方法的重载，可以传递 LockModeType 采参数。用于在获取实体时上锁： Post post = entityManager.find(Post.class, id, lockMode); Spring Data JpaRepository 未提供此选项，但我们可以使用自定义 Spring Data Repository 来实现。 例如，可以让 PostRepository 继承 JpaRepository，CustomPostRepository： @Repository public interface PostRepository extends JpaRepository<Post, Long>, CustomPostRepository { } In the CustomPostRepository interface, we can define a lockById method like this: https://springdoc.cn/spring-boot-and-mybatis-plus/ Wed, 01 Nov 2023 15:19:27 +0800 https://springdoc.cn/spring-boot-and-mybatis-plus/ MyBatis Plus 是 MyBatis 框架的一个增强。除了基本的 MyBatis 功能外，它还提供了快速的 CURD 方法，以及投影查询、分页查询、动态条件等等功能，极大的提高了开发效率。 本文将会通过案例教你如何在 Spring Boot 中整合 MyBatis Plus。 文中使用的软件版本如下： Spring Boot：3.0.3 MySQL：8.0.0 MyBatis Plus：3.5.4 初始化演示数据 首先在本地数据库执行以下 SQL 脚本，创建一张名为 t_user 的数据表： CREATE TABLE `t_user` ( `id` int unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID', `create_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', `enabled` tinyint unsigned NOT NULL COMMENT '是否启用。0：禁用，1：启用', `name` varchar(50) COLLATE utf8mb4_general_ci NOT NULL COMMENT '名字', PRIMARY KEY (`id`), UNIQUE KEY `name` (`name`) ) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='用户'; 然后再执行如下脚本，创建初始记录： https://springdoc.cn/spring-security-configuring-urls/ Wed, 01 Nov 2023 14:19:27 +0800 https://springdoc.cn/spring-security-configuring-urls/ 1、概览 本文将带你了解如何在 Spring Security 中针对不同的 URL 进行不同的安全配置。 2、设置 创建应用，在 pom.xml 中添加 Web 和 Security 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> 3、创建 API 创建一个包含两个 API 的 RESTful 服务：Product（产品） API 和 Customer（客户） API。 3.1、Product API 创建 ProductController。它包含一个 getProducts 方法，该方法返回产品列表： @RestController("/products") public class ProductController { @GetMapping public List<Product> getProducts() { return new ArrayList<>(Arrays.asList( new Product("Product 1", "Description 1", 1.0), new Product("Product 2", "Description 2", 2.0) )); } } 3.2、Customer API 同样，定义 CustomerController： https://springdoc.cn/spring-cloud-gateway-url-rewriting/ Wed, 01 Nov 2023 10:30:27 +0800 https://springdoc.cn/spring-cloud-gateway-url-rewriting/ 1、简介 Spring Cloud Gateway 的常见用例是作为一个网关，代理一个或多个服务，从而为客户端提供更简单的消费方式。 本文将带你了解如何在将请求发送到后端之前，通过重写 URL 来自定义暴露的 API 的不同方式。 2、Spring Cloud Gateway 快速回顾 Spring Cloud Gateway 项目是在流行的 Spring Boot 2 和 Project Reactor 的基础上构建的，因此继承了其主要特性： 响应式，资源占用低 支持 Spring Cloud 生态系统的所有功能（服务发现、配置等） 使用标准 Spring 模式轻松扩展和/或定制 这里只列出它的主要概念，更多详细信息请参阅 中文文档： Route：路由，在网关中，匹配的传入请求会经历一系列的处理步骤。 Predicate：针对 ServerWebExchange 进行评估的 Java 8 Predicate。 Filters：可以检查、更改 ServerWebExchange 的 GatewayFilter 实例。网关支持全局 Filter 和按路由的 Filter。 简而言之，接收请求的处理顺序如下： 网关使用与每条路由相关的 Predicate 来查找哪条路由可以处理请求。 一旦找到路由，请求（ServerWebExchange 实例）就会通过每个配置的 Filter，直到最终发送到后端。 当后端发送回响应或出现错误（例如超时或连接重置）时，Filter 可以再次处理响应，然后再将其发送回客户端。 3、基于配置的 URL 重写 回到本文的主题，让我们看看如何定义一个路由，在将请求发送到后端之前重写传入的 URL。例如，假设输入的请求格式为 /api/v1/customer/*，后端 URL 应为 http://v1.customers/api/*。这里，使用 “*” 来表示 “在此之后的任何内容”。 https://springdoc.cn/spring-security-enable-logging/ Wed, 01 Nov 2023 10:15:56 +0800 https://springdoc.cn/spring-security-enable-logging/ 1、概览 使用 Spring Security 时，可能需要把日志级别设置得更高一些。例如，可能需要检查用户的角色或端点的安全配置。或者，可能还需要更多关于身份认证或授权的信息，例如查看为什么用户无法访问某个端点。 本文将带你了解如何修改 Spring Security 日志级别。 2、配置 Spring Security 日志 与其他 Spring 或 Java 应用一样，可以使用日志库，并为 Spring Security 模块定义日志级别。 通常，可以进行如下配置： <logger name="org.springframework.security" level="DEBUG" /> 如果运行的是 Spring Boot 应用，则可以在 application.properties 文件中对此进行配置： logging.level.org.springframework.security=DEBUG 同样，也可以使用 yaml： logging: level: org: springframework: security: DEBUG 这样，就可以查看有关身份认证或 Filter Chain 的日志。此外，还可以使用 trace 级别进行更深入的 debug。 Spring Security 还能记录有关请求和应用的 Filter 的特定信息： @EnableWebSecurity public class SecurityConfig { @Value("${spring.websecurity.debug:false}") boolean webSecurityDebug; @Bean public WebSecurityCustomizer webSecurityCustomizer() { return (web) -> web.debug(webSecurityDebug); } // . https://springdoc.cn/spring-oauth2resttemplate/ Wed, 01 Nov 2023 09:33:32 +0800 https://springdoc.cn/spring-oauth2resttemplate/ 1、概览 本文将带你了解如何使用 Spring OAuth2RestTemplate 进行 OAuth2 REST 调用。 创建一个 Spring Web 应用，用于列出 GitHub 账户下的所有仓库。 2、Maven 依赖 首先，需要在 pom.xml 中添加 spring-boot-starter-security 和 spring-security-oauth2-autoconfigure 依赖。由于构建的是 Web 应用，因此还需要包含 spring-boot-starter-web 和 spring-boot-starter-thymeleaf Starter。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.security.oauth.boot</groupId> <artifactId>spring-security-oauth2-autoconfigure</artifactId> <version>2.6.8</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> 3、OAuth2 Properties 接下来，在 application.properties 文件中添加 OAuth 配置，以连接到 GitHub 账户： # 替换为你的 CLIENT_ID github.client.clientId=[CLIENT_ID] # 替换为你的 CLIENT_SECRET github.client.clientSecret=[CLIENT_SECRET] github.client.userAuthorizationUri=https://github.com/login/oauth/authorize github.client.accessTokenUri=https://github.com/login/oauth/access_token github.client.clientAuthenticationScheme=form github.resource.userInfoUri=https://api.github.com/user github.resource.repoUri=https://api.github.com/user/repos 注意，需要用 GitHub OAuth App 中的值替换 [CLIENT_ID] 和 [CLIENT_SECRET] 。你可以按照 创建 OAuth App 指南在 GitHub 上注册一个新的应用： https://springdoc.cn/springboot-auto-configuration-principle-analysis/ Tue, 31 Oct 2023 18:42:39 +0800 https://springdoc.cn/springboot-auto-configuration-principle-analysis/ 1、什么是 Spring Boot 自动配置 首先介绍一下什么是 Spring Boot，Spring Boost 是基于 Spring 框架开发出来的功能更强大的 Java 程序开发框架，其最主要的特点是：能使程序开发者快速搭建一套开发环境。Spring Boot 能将主流的开发框架（例如 SpringMVC、Dubbo、Mybatis、Redis 等），做到像 Maven 导入 Jar 包一样的简洁快速，做到开箱即用。其中最关键的技术就是 Spring Boot 定制的各种 Starter，通 Maven 引入 Starter 就能快速搭建开发环境。 2、SpringBoot Starter自动装配案例 在以前单独使用 SpringMVC Web 编程框架时，我们需要单独配置 DispatcherServlet 和 Tomcat，使用 Spring Boot 之后，我们只需要引入 spring-boot-Starter-web 就能直接开始编写 Controller 等 Web 相关的代码，这就是 Spring Boot 为们提供的开箱即用的便捷能力，下面就以 spring-boot-Starter-web 来说明 Spring Boot自动配置的关键原理。 3、SpringBoot 自动装配案例源码解析 3.1、DispatcherServlet 的自动配置原理 首先我们定位到 Spring Boot 自动配置的 Maven 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-autoconfigure</artifactId> <version>${spring-boot.version}</version> </dependency> 在依赖的 Jar 包中我们可以在 META-INF/spring. https://springdoc.cn/dev-webfux-crud-app/ Tue, 31 Oct 2023 10:40:56 +0800 https://springdoc.cn/dev-webfux-crud-app/ WebFlux 最为人所诟病的是数据库的支持问题，毕竟数据是一个应用的生命，我们接触的大部分应用程序都是有数据库的，而 WebFlux 在这一方面的支持行一直比较弱，这也是大家总是吐槽它的原因。 不过从 Spring 5 开始，这一问题得到了一定程度的缓解。 Spring 官方在 Spring5 发布了响应式 Web 框架 Spring WebFlux 之后急需能够满足异步响应的数据库交互 API，不过由于缺乏标准和驱动，Pivotal 团队开始自己研究响应式关系型数据库连接 Reactive Relational Database Connectivity，并提出了 R2DBC 规范 API 用来评估可行性并讨论数据库厂商是否有兴趣支持响应式的异步非阻塞驱动程序。最早只有 PostgreSQL 、H2、MSSQL 三家数据库厂商，不过现在 MySQL 也加入进来了，这是一个极大的利好。目前 R2DBC 的最新版本是 0.9.0.RELEASE。 本系列接下来的文章中将会和大家演示 R2DBC 的用法，但是今天我们还是先来看看 WebFlux + MongoDB 的用法，毕竟这是 WebFlux 较早支持的数据库之一，各种 API 都比较成熟，我们一步一步来。 1、项目创建 方便起见，我们这里就直接创建 Spring Boot 项目，首先创建一个 Spring Boot 项目，引入 MongoDB 依赖和 WebFlux 依赖，如下： 注意我们这里选择的 MongoDB 依赖是 Spring Data Reactive MongoDB，千万别选错了。 项目创建完成后，我们先在 application.properties 中对 MongoDB 进行简单配置，如下： https://springdoc.cn/spring-security-authentication-mongodb/ Tue, 31 Oct 2023 10:05:30 +0800 https://springdoc.cn/spring-security-authentication-mongodb/ 1. Overview Spring Security 提供了不同的身份认证系统，例如通过数据库和 UserDetailService。 有时可能不想使用 JPA 持久层，而是想使用 MongoDB Repository。本文将带你了解如何使用 Spring Security 和 MongoDB 对用户进行认证。 2、Spring Security 使用 MongoDB 进行认证 MongoDB Repository 与 JPA Repository 类似不过，我们需要设置不同的配置。 2.1、Maven 依赖 本文使用嵌入式 MongoDB。首先，添加 spring-boot-starter-data-mongodb 和 de.flapdoodle.embed.mongo 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> <dependency> <groupId>de.flapdoodle.embed</groupId> <artifactId>de.flapdoodle.embed.mongo</artifactId> <version>3.3.1</version> </dependency> 2.2、配置 创建配置类： @Configuration public class MongoConfig { private static final String CONNECTION_STRING = "mongodb://%s:%d"; private static final String HOST = "localhost"; @Bean public MongoTemplate mongoTemplate() throws Exception { int randomPort = SocketUtils. https://springdoc.cn/spring-boot-mongodb-logging/ Tue, 31 Oct 2023 09:25:13 +0800 https://springdoc.cn/spring-boot-mongodb-logging/ 1、概览 在使用 Spring Data MongoDB 时，可能需要比默认级别（INFO）更高的日志，以查看执行语句或查询参数等一些附加信息。 2、配置 MongoDB 查询日志 Spring Data MongoDB 通过 MongoOperations 接口或其主要的实现 MongoTemplate 来访问数据，因此只需为 MongoTemplate 类配置调 Debug 级别的日志即可。 与其他 Spring 或 Java 应用一样，可以使用日志库并为 MongoTemplate 定义日志级别。类似于如下： <logger name="org.springframework.data.mongodb.core.MongoTemplate" level="DEBUG" /> 如果是 Spring Boot 应用，可以直接在 application.properties 文件中进行配置： logging.level.org.springframework.data.mongodb.core.MongoTemplate=DEBUG 同样，也可以使用 YAML 文件： logging: level: org: springframework: data: mongodb: core: MongoTemplate: DEBUG 3、日志测试类 创建一个 Book 类： @Document(collection = "book") public class Book { @MongoId private ObjectId id; private String bookName; private String authorName; // getter 和 setter 方法 } 创建一个简单的测试类用于测试，并查看输出日志。 https://springdoc.cn/spring-6-jdbcclient-api/ Tue, 31 Oct 2023 08:20:41 +0800 https://springdoc.cn/spring-6-jdbcclient-api/ 1、概览 本文将带你了解 Spring 6.1 中新添加的 JdbcClient 接口，它提供了 Fluent 风格的 API，统一了 JdbcTemplate 和 NamedParameterJdbcTemplate 的 Facade，支持链式操作。 有了 JdbcClient 后就可以使用 Fluent 风格的 API 定义查询、设置参数以及执行数据库操作了。 该功能简化了 JDBC 操作，使其更易读、更易懂。然而，对于 JDBC 批处理操作和存储过程的调用，仍然需要使用 JdbcTemplate 和 NamedParameterJdbcTemplate 类。 本文使用 H2 数据库来演示 JdbcClient 的功能。 2、数据库设置 创建 student 表： CREATE TABLE student ( student_id INT AUTO_INCREMENT PRIMARY KEY, student_name VARCHAR(255) NOT NULL, age INT, grade INT NOT NULL, gender VARCHAR(10) NOT NULL, state VARCHAR(100) NOT NULL ); -- Student 1 INSERT INTO student (student_name, age, grade, gender, state) VALUES ('John Smith', 18, 3, 'Male', 'California'); -- Student 2 INSERT INTO student (student_name, age, grade, gender, state) VALUES ('Emily Johnson', 17, 2, 'Female', 'New York'); --More insert statements. https://springdoc.cn/spring-boot-datafieldmaxvalueincrementer/ Mon, 30 Oct 2023 15:17:12 +0800 https://springdoc.cn/spring-boot-datafieldmaxvalueincrementer/ DataFieldMaxValueIncrementer 是 spring-jdbc 项目中的一个接口。用于在应用中生成连续、自增的序列。可用于 主键ID、订单号、流水号 等等。 它基于数据库实现，主要有 2 大子类。 AbstractSequenceMaxValueIncrementer：用于支持序列（SEQUENCE）的数据库（如 Oracle），使用标准的数据库序列。 AbstractColumnMaxValueIncrementer：用于不支持序列的数据库（如，MYSQL），使用一张表来模拟。 spring-jdbc 已经为当前流行的关系型数据库提供了具体的实现，类体系结构如下： DataFieldMaxValueIncrementer |-AbstractDataFieldMaxValueIncrementer |-AbstractSequenceMaxValueIncrementer |-OracleSequenceMaxValueIncrementer # Oracle 数据库 |-PostgresSequenceMaxValueIncrementer # Postgres 数据库 |-SqlServerSequenceMaxValueIncrementer # SqlServer 数据库 |- ... # 还有一些其他的，这里忽略 |-AbstractColumnMaxValueIncrementer |-MySQLMaxValueIncrementer # MYSQL 数据库 DataFieldMaxValueIncrementer DataFieldMaxValueIncrementer 接口只有 3 个方法，很简单。 public interface DataFieldMaxValueIncrementer { int nextIntValue() throws DataAccessException; long nextLongValue() throws DataAccessException; String nextStringValue() throws DataAccessException; } nextIntValue：以 int 类型返回下一个序列。 nextLongValue：以 long 类型返回下一个序列。 nextStringValue：以 String 类型返回下一个序列。 使用 MySQLMaxValueIncrementer 本文以 MySQLMaxValueIncrementer 为例（毕竟 MYSQL 最流行）。 https://springdoc.cn/spring-security-map-authorities-jwt/ Mon, 30 Oct 2023 10:23:15 +0800 https://springdoc.cn/spring-security-map-authorities-jwt/ 1、简介 本文将带你了解如何自定义从 JWT（JSON Web Token）Claim 到 Spring Security 权限（Authority）的映射。 2、背景 基于 Spring Security 的应用接收到请求时，它会经过一系列步骤，本质上旨在实现两个目标。 认证请求，以便应用知道谁在访问它 决定通过身份认证的请求是否可以执行相关操作 对于使用 JWT 的应用，授权方面包括： 从 JWT payload（通常是 scope 或 scp Claim）中提取 Claim 值 将这些 Claim 声明映射到一组 GrantedAuthority 对象中 一旦 Security 引擎设置了这些权限，它就可以评估是否有任何访问限制适用于当前请求，并决定是否可以继续处理。 3、默认的映射 在开箱即用的情况下，Spring 使用一种直接的策略将 Claim 声明转换为 GrantedAuthority 实例。首先，它会提取 scope 或 scp Claim，并将其拆分成一个字符串列表。接下来，它会为每个字符串创建一个新的 SimpleGrantedAuthority，使用前缀 SCOPE_，后跟 scope 值。 接下来，创建一个简单的端点来演示这个策略。看看 Authentication 实例有哪些关键属性。 @RestController @RequestMapping("/user") public class UserRestController { @GetMapping("/authorities") public Map<String,Object> getPrincipalInfo(JwtAuthenticationToken principal) { Collection<String> authorities = principal.getAuthorities() . https://springdoc.cn/xhr-cors-multiple-values-error/ Mon, 30 Oct 2023 10:16:40 +0800 https://springdoc.cn/xhr-cors-multiple-values-error/ 1. 问题 在浏览器中进行跨域请求一个接口时报错如下： Access to XMLHttoRequest at ‘https://xxx.lzw.me/abc/getToken from origin “http://localhost:3001 has been blocked by CORS policy: Response to preflight request doesn’t pass access control check: The ‘Acess-Control-Allow-Origin’ header contains multiple values ‘*, *”. but only one is allowed. 2. 原因 从报错信息上理解，是 Acess-Control-Allow-Origin 的值为 *, *，设置了多个。从 nginx 配置上查看设置的值是 *。以非跨域的方式请求该接口，则可以在 Response 中看到 header 信息中包含了两个 Acess-Control-Allow-Origin 的设置。那么原因就是在 nginx 之外的其它网关或应用程序中还设置了该 header 值。找到它并移除个性化的设置逻辑即可。 3. 解决方法 如果 nginx 出口网关的设置是多余的，CORS 在应用程序层已有管理，则可以直接移除此处的配置。 如果是应用程序内部针对该接口添加了设置，考虑到需支持允许所有接口跨域访问，应修改应用程序移除相关逻辑。 如果希望在 nginx 层作统一配置管理，也可在应用程序出口网关层作 header 过滤。例如针对 Spring zuul 网关的设置实例： https://springdoc.cn/spring-singleton-concurrent-requests/ Mon, 30 Oct 2023 09:40:53 +0800 https://springdoc.cn/spring-singleton-concurrent-requests/ 1、Spring Bean 和 Java 堆内存 Java 堆是一个全局共享内存，应用中的所有运行线程都可以访问它。当 Spring 容器创建 Singleton Scope Bean 时，该 Bean 将存储在堆中。这样，所有并发线程都能指向同一个 Bean 实例。 2、如何处理并发请求？ 举例来说，Spring 应用中有一个名为 ProductService 的单例 Bean： @Service public class ProductService { private final static List<Product> productRepository = asList( new Product(1, "Product 1", new Stock(100)), new Product(2, "Product 2", new Stock(50)) ); public Optional<Product> getProductById(int id) { Optional<Product> product = productRepository.stream() .filter(p -> p.getId() == id) .findFirst(); String productName = product.map(Product::getName) .orElse(null); System.out.printf("Thread: %s; bean instance: %s; product id: %s has the name: %s%n", currentThread(). https://springdoc.cn/spring-cloud-disable-discovery-clients/ Mon, 30 Oct 2023 09:01:58 +0800 https://springdoc.cn/spring-cloud-disable-discovery-clients/ 1、概览 在 Spring Cloud 中可以通过配置文件来启用、禁用服务发现，而不需要改动代码。 2、 设置 Eureka Server 和 Eureka Client 先创建一个 Eureka 服务器和一个 Discovery Client。 Eureka 服务创建过程，略！ 2.1、Discovery Client 设置 创建 “Discovery Client” 应用，在 Eureka Server 上进行注册。 在 pom.xml 中添加 Web 和 Eureka Client starter 依赖： <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> 还需要在 dependencyManagement 中添加 spring-cloud-starter-parent 依赖，用于定义 cloud 组件的版本。 如果使用 Spring Initializr 创建项目，这些参数已经设置好了。如果没有，可以手动添加到 pom.xml 文件中： <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-parent</artifactId> <version>${spring-cloud-dependencies.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <properties> <spring-cloud-dependencies. https://springdoc.cn/spring-boot-properties-migrator/ Sun, 29 Oct 2023 16:34:37 +0800 https://springdoc.cn/spring-boot-properties-migrator/ 1、简介 本文将带你了解 spring-boot-properties-migrator 模块，它是 Spring 为促进 Spring Boot 升级而提供的支持。用于帮助迁移 application properties。 随着每个 Spring Boot 版本的升级，可能会有一些属性被标记为已弃用、不再支持或新引入的属性。Spring 为每个升级发布了详细的 变更日志。然而，阅读这些变更日志可能会有些繁琐。这就该 spring-boot-properties-migrator 出场了，它通过为我们的设置提供个性化的信息来帮助我们进行属性迁移。 让我们来看看如何使用。 2、Demo 应用 把 Spring Boot 应用从 2.3.0 升级到 2.6.3。 2.1、Properties 在演示应用中，有两个 properties 文件。在默认 properties 文件 application.properties 中，添加如下配置： spring.resources.cache.period=31536000 spring.resources.chain.compressed=false spring.resources.chain.html-application-cache=false dev Profile YAML 文件 application-dev.yaml： spring: resources: cache: period: 31536000 chain: compressed: true html-application-cache: true properties 文件包含了几个在 Spring Boot 2.3.0 和 2.6.3 之间被替换或移除的属性。 同时提供了 .properties 和 .yaml 文件，以便更好地进行演示。 2.2、添加依赖 添加 spring-boot-properties-migrator 模块。 https://springdoc.cn/spring-security-exceptions/ Sun, 29 Oct 2023 16:12:41 +0800 https://springdoc.cn/spring-security-exceptions/ 1、概览 本文通过一个示例来带你了解如何处理 Spring Security Resource Server 产生的 Spring Security 异常。 2、Spring Security Spring Security 是 Spring 的一个子项目。它试图将 Spring 项目中的所有用户访问控制功能进行整合。访问控制允许限制特定用户或角色在应用中可以执行的选项。 在本例中，我们重点关注 Exception Handler 的配置。Spring Security 提供了三种不同的接口来实现这一目的并控制产生的事件： Authentication Success（认证成功）Handler Authentication Failure（认证失败）Handler Access Denied（拒绝访问）Handler 3、Security Configuration 首先，配置类必须创建一个 SecurityFilterChain Bean。它将负责管理应用的所有安全配置。因此，我们必须在这里引入 Handler。 定义所需的配置： @Bean public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http.csrf() .disable() .httpBasic() .disable() .authorizeRequests() .antMatchers("/login") .permitAll() .antMatchers("/customError") .permitAll() .antMatchers("/access-denied") .permitAll() .antMatchers("/secured") .hasRole("ADMIN") .anyRequest() .authenticated() .and() .formLogin() .failureHandler(authenticationFailureHandler()) .successHandler(authenticationSuccessHandler()) .and() .exceptionHandling() .accessDeniedHandler(accessDeniedHandler()) .and() .logout(); return http. https://springdoc.cn/spring-graphql-error-handling/ Sun, 29 Oct 2023 14:36:19 +0800 https://springdoc.cn/spring-graphql-error-handling/ 1、概览 本文将带你了解如何在 Spring Boot 中处理 GraphQL 异常，以及 GraphQL 规范中关于错误响应的规定。 2、根据 GraphQL 规范进行响应 根据 GraphQL 规范，每个接收到的请求都必须返回一个格式良好的响应。这个格式良好的响应是一个 Map，包含了来自相应成功或失败的请求操作的数据或错误。此外，响应可能包含部分成功的结果数据和字段错误。 响应 Map 的关键 key 是 errors、data 和 extensions。 响应中的 errors 描述了请求操作过程中出现的任何异常、错误。如果没有错误发生，则响应中不得出现 errors 字段。接下来，我们将了解规范中描述的不同类型的错误。 data 字段描述了成功执行所请求操作的结果。如果操作是 Query，该字段就是 Query Root Operation 类型的对象。如果操作是 Mutation，则该字段是 Mutation Root Operation 类型的对象。 如果请求的操作在执行前就因信息缺失、验证错误或语法错误而失败，那么响应中就必须没有 data 字段。如果操作在执行过程中失败，且结果不成功，则 data 必须为 null。 响应 map 可能包含一个名为 extensions 的附加字段，它是一个 map 对象。该字段便于实现者在响应中提供他们认为合适的其他自定义内容。因此，对其内容格式没有额外的限制。 如果响应中没有 data 字段，则必须有 errors 字段，并且必须至少包含一个 error。此外，它还应说明失败的原因。 下面是一个 GraphQL 错误示例： mutation { addVehicle(vin: "NDXT155NDFTV59834", year: 2021, make: "Toyota", model: "Camry", trim: "XLE", location: {zipcode: "75024", city: "Dallas", state: "TX"}) { vin year make model trim } } 当违反唯一性约束时，错误响应如下所示： https://springdoc.cn/spring-injecting-all-annotated-beans/ Sun, 29 Oct 2023 10:00:05 +0800 https://springdoc.cn/spring-injecting-all-annotated-beans/ 1、概览 本文将带你了解如何在 Spring 中获取到所有带自定义注解的 Bean。 不同的 Spring 版本，实现方式也不同。 2、使用 Spring Boot 2.2 或更高版本 从 Spring Boot 2.2 起，可以使用 getBeansWithAnnotation 方法。 创建一个示例。首先，定义自定义注解。注意，要使用 @Retention(RetentionPolicy.RUNTIME) 元注解，以确保程序在运行时可以访问注解： @Retention(RetentionPolicy.RUNTIME) public @interface MyCustomAnnotation { } 现在，用注解定义第一个 Bean（还要添加 @Component 注解）： @Component @MyCustomAnnotation public class MyComponent { } 然后，定义另一个带有注解的 Bean。不过，这次通过 @Configuration 中的 @Bean 方法来创建： public class MyService { } @Configuration public class MyConfigurationBean { @Bean @MyCustomAnnotation MyService myService() { return new MyService(); } } 现在，写一个测试，测试 getBeansWithAnnotation 方法能否获取到上述两个 Bean： https://springdoc.cn/spring-boot-restclient/ Sun, 29 Oct 2023 08:55:55 +0800 https://springdoc.cn/spring-boot-restclient/ 1、简介 RestClient 是 Spring 6.1 M2 中引入的同步 HTTP 客户端，它取代了 RestTemplate。同步 HTTP 客户端以阻塞方式发送和接收 HTTP 请求和响应，这意味着它会等待每个请求完成后才继续下一个请求。 本文将带你了解 RestClient 的功能以及它与 RestTemplate 的比较。 2、RestClient 和 RestTemplate RestTemplate，顾名思义，是基于模板设计模式构建的。它是一种行为设计模式，用于在方法中定义算法的框架，允许子类为某些步骤提供特定的实现。虽然这是一种强大的模式，但它会导致需要进行方法覆写，这可能是不方便的。 为了改进这一点，RestClient 采用了 Fluent API。Fluent API 也是一种设计模式，它允许以一种使代码更易读和表达的方式进行方法链式调用，通常无需使用中间变量。 从创建一个基本的 RestClient 开始： RestClient restClient = RestClient.create(); 3、使用各种 HTTP 方法发起请求 与 RestTemplate 或其他 REST 客户端类似，RestClient 可以使用不同的 HTTP 方法发起请求。 创建一个用于操作的 Article 类： public class Article { Integer id; String title; // 构造函数和 getter/setter } 3.1、使用 GET 请求获取资源 GET 请求用于检索 Web 服务器上指定资源的数据，而不对其进行修改。通常，这是一个只读的操作！ 获取服务器响应的字符串（String）： https://springdoc.cn/spring-boot-download-file-name-garbled/ Sat, 28 Oct 2023 08:28:11 +0800 https://springdoc.cn/spring-boot-download-file-name-garbled/ 对于文件的下载功能来说，我归纳为 2 头 1 流。极其简单。 Content-Type 头，告诉客户端文件类型。 Content-Disposition 头，告诉客户端对于这个文件的处理方式（在浏览器中显示，还是下载）。 Output 流，写入文件内容到客户端。 文件名称乱码的问题 Content-Disposition 头有三个属性值，可以指定文件的名称。 name filename filename* 至于区别，我也说不大清楚。反正是有个规范，我感觉很乱。具体可以参考如下链接： https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Content-Disposition 这就是容易出问题的地方了，由于文件名称设置方法不正确。或者是浏览器不兼容问题，如果 文件名称包含中文，可能会导致 下载文件名称乱码： response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + "中文の文件.txt"); 如上，直接用 + 拼接中文字符串，在谷歌浏览器中下载就是乱码。 常见的解决方案 以下我是在网上看到的一些解决方案。 对文件名称进行URI编码 response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + URLEncoder.encode("中文の文件.txt", StandardCharsets.UTF_8)); 修改字符编码 response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + new String("中文の文件.txt".getBytes("GBK"),"ISO-8859-1")); 经过测试，上面2种办法都OK。 比较优雅的方式 Spring 提供了一个工具类: org.springframework.http.ContentDisposition，专门用于处理文件下载中的 Content-Disposition Header，它会自动处理好中文文件名称的编码问题。 ContentDisposition 使用实在是太简单了，这里就不多说了，给一个完整的使用示例就能看明白。 package io.springboot.demo.web.controller; import java.io.IOException; import java.nio.charset.StandardCharsets; import javax.servlet.http.HttpServletResponse; import org.springframework.http.ContentDisposition; import org.springframework.http.HttpHeaders; import org.springframework.web.bind.annotation.GetMapping; import org. https://springdoc.cn/spring-boot-docker-start-with-profile/ Fri, 27 Oct 2023 14:55:26 +0800 https://springdoc.cn/spring-boot-docker-start-with-profile/ 1、简介 在容器化大行其道的今天，越来越多人选择把 Spring Boot 应用部署到 Docker 中。 本文将带你了解在 Docker 容器中启动 Spring Boot 应用时，如何设置其 Profile。 2、基本的 Dockerfile 一般来说，要容器化 Spring Boot 应用，只需提供一个 Dockerfile。 Spring Boot 应用的最小 Dockerfile，如下： FROM openjdk:11 COPY target/*.jar app.jar ENTRYPOINT ["java", "-jar", "/app.jar"] 然后，可以通过 docker build 来构建 Docker 镜像： docker build --tag=docker-with-spring-profile:latest . 接着，我们就可以通过 docker-with-spring-profile 镜像运行应用了： docker run docker-with-spring-profile:latest 你可以注意到，Spring Boot 应用以 “default” Profile 启动： 2022-04-22 22:34:25.268 INFO 1 --- [main] c.b.docker.spring.DemoApplication: Starting DemoApplication using Java 11.0.14.1 on ea8851bea75f with PID 1 (/app. https://springdoc.cn/cascade-delete-unidirectional-associations-spring/ Fri, 27 Oct 2023 14:19:00 +0800 https://springdoc.cn/cascade-delete-unidirectional-associations-spring/ 简介 本文将带你了解，当无法依赖 CascadeType 机制来将状态转换从父实体传播到子实体时，如何使用 Spring Data JPA 级联删除单向关联， Domain Model 假设我们的系统中有以下实体： Post 实体是该实体层次结构的根（root），子实体只使用单向 @ManyToOne 或 @OneToOne 关联，用于映射一个一对多或一对一表关系的底层外键。 Post root 实体如下： @Entity @Table(name = "post") public class Post { @Id private Long id; private String title; // getter/setter 方法省略 } 请注意，没有双向的 @OneToMany 或 @OneToOne 关联，可以允许我们从父级 Post 级联 DELETE 操作到 PostComment、PostDetails 或 PostTag 子实体。 PostComment 实体使用单向 @ManyToOne 关联映射 post_id 外键列： @Entity @Table(name = "post_comment") public class PostComment { @Id @GeneratedValue private Long id; @ManyToOne(fetch = FetchType. https://springdoc.cn/spring-security-httpsecurity-vs-websecurity/ Fri, 27 Oct 2023 13:24:07 +0800 https://springdoc.cn/spring-security-httpsecurity-vs-websecurity/ 1、概览 Spring Security 有 2 个核心的组件：HttpSecurity 和 WebSecurity。 2、Spring Security Spring Security 是 Spring Framework 的扩展，是一个功能强大、高度可定制的安全框架。它为基于 Jakarta® EE 的企业软件应用提供全面的安全服务。它旨在处理身份验证、授权、防止常见安全漏洞等问题。 Spring Security 与两个重要组件 HttpSecurity 和 WebSecurity 紧密集成。 HttpSecurity 主要负责配置 HTTP 请求的安全，而 WebSecurity 则侧重于配置基于 Web 的安全。 Spring Security 的核心依赖于 AuthenticationManager、UserDetailsService 和 UserDetails 等基本组件。这些组件构成了 Spring Security 的基础。通过它们，我们可以实现身份认证、管理用户详情并有效定义访问控制。 3、HttpSecurity HttpSecurity 在配置 HTTP 请求的授权方面起到核心作用。它允许我们基于各种条件定义访问规则，包括 URL、HTTP 方法和用户角色，以确保对应用程序的不同部分进行安全访问。 链式方法调用是 HttpSecurity 的一个强大特性，它使我们能够流畅地表达安全配置。通过方法链，我们可以定义特定端点的安全行为，处理身份认证机制，并无缝设置自定义访问规则。这种方式让安全配置更加灵活和易于管理。 HttpSecurity 的一个关键特性是基于角色和权限进行访问配置。我们可以指定访问特定URL 所需的角色或权限。因此，我们可以对应用程序的安全性进行细粒度控制。 HttpSecurity 还可以实现平滑处理登录和注销功能。因此，我们可以配置自定义的登录页面、认证成功和失败的处理方式。它还允许我们实现自定义的注销行为，提升用户体验和安全性。 在使用 HttpSecurity 配置授权时，重要的是要解决安全问题。这些包括防止未经授权的访问、确保安全的身份认证机制、防止会话固定攻击，并防范常见的Web漏洞。 使用 HttpSecurity 来配置授权。 @Configuration @EnableWebSecurity public class HttpSecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http. https://springdoc.cn/spring-boot-3-1-connectiondetails-abstraction/ Fri, 27 Oct 2023 09:19:42 +0800 https://springdoc.cn/spring-boot-3-1-connectiondetails-abstraction/ 1、概览 本文将带你了解 Spring Boot 3.1 中引入的 ConnectionDetails 接口，用于编程式定义连接属性（可从外部服务中加载）。Spring Boot 提供了开箱即用的抽象，用于与远程服务集成，如关系型数据库、NoSQL 数据库、消息队列服务等 传统上，连接信息都是配置在 application.properties 文件中的。因此，如果需要从 AWS Secret Manager、Hashicorp Vault 等外部服务加载连接配置的话就比较麻烦。 为了解决这个问题，Spring Boot 引入了 ConnectionDetails。这个接口是空的，即标记接口。Spring 提供了该接口的子接口，如 JdbcConnectionDetails、CassandraConnectionDetails、KafkaConnectionDetails 等。它们可以在 Spring 配置类中实现和指定为 Bean。之后，Spring 将依赖这些配置 Bean 来动态检索连接属性，而不是静态的 application.properties 文件。 2、场景 把敏感的配置信息（如数据库）定义在 application.properties 文件中存在一定的安全隐患。最好的方式是使用专业的私密信息存储服务。 HashiCorp Vault 是一款企业级私密信息管理工具，用于安全地存储和访问敏感数据，例如API密钥、数据库凭据、密码等。支持多种认证方法和加密机制，并提供 API 和命令行界面，以便与应用程序和工具集成。还支持动态秘密生成、密钥轮换和审计日志等功能，使数据的管理和安全性更加便捷和可靠。 Spring Boot 从 Vault 中读取敏感信息的流程如下： Spring Boot 通过 Secret Key 调用 Vault 服务来获取连接配置信息。然后，使用该配置和远程服务创建连接。 4、ConnectionDetails 通过 ConnectionDetails 接口，Spring Boot 应用可以自行发现连接细节（Connection Detail），而无需任何手动干预。注意，ConnectionDetails 优先于 application.properties 文件。不过，仍有一些非连接属性（如 JDBC 连接池大小）可以通过 application.properties 文件进行配置。 https://springdoc.cn/spring-responsebodyadvice-encode-body/ Thu, 26 Oct 2023 15:24:41 +0800 https://springdoc.cn/spring-responsebodyadvice-encode-body/ 在前文 《在 Spring Boot 中通过 RequestBodyAdvice 统一解码请求体》 中，我们介绍了如何通过 RequestBodyAdvice 组件统一地解码客户端编码后的请求体。 有请求，就有响应，本文将会带你了解如何使用 ResponseBodyAdvice 来统一对响应体进行编码。 这种场景比较常见，常用于 APP 客户端和服务器之间的通信。为了避免中间人通过抓包直接获取到服务器的响应数据，所以会对数据进行加密（AES、3DES、RSA 等等）。 客户端获取到加密数据后，使用本地存储的密钥进行解密从而得到原始数据。由于密钥没有经过网络传输，意味着加密数据不会轻易被人破解。当然，密钥由于存储在客户端，需要通过混淆等手段保证它不会被轻易的破解、获取（这种安全话题超出了本文的范畴）！ ResponseBodyAdvice ResponseBodyAdvice spring mvc 提供的一个增强接口，用于在返回对象被 HttpMessageConverter 执行序列化之前对其进行一些自定义的操作。 public interface ResponseBodyAdvice <T> { boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType); @Nullable T beforeBodyWrite(@Nullable T body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response); } 这是一个带泛型 <T> 的接口，T 表示返回的对象类型，这决定了它会对哪些返回的对象生效。另外，它比 RequestBodyAdvice 简单，它只有 2 个方法。 supports：用于确定该实现类是否支持对响应体进行处理，通过 returnType 参数可以获取到 Controller 方法的返回类型等信息。 beforeBodyWrite：该方法在响应体写入之前被调用，在这个方法中可以通过参数获取到最终要响应给客户端的对象，我们可以对这个对象进行一些操作，最后返回修改后的对象。 接下来我们通过一个示例来了解如何使用 ResponseBodyAdvice。 https://springdoc.cn/spring-webserviceservertest/ Thu, 26 Oct 2023 12:39:32 +0800 https://springdoc.cn/spring-webserviceservertest/ 1、简介 本文将带你了解如何使用 @WebServiceServerTest 为 Spring Boot 开发的 SOAP Web Service 编写集成测试。 2、测试 Spring Web Service 在 Spring Web Service 中，端点是服务器端 Service 实现的关键概念。专门的 @Endpoint 注解将类标记为 Web Service 端点。这些端点负责接收 XML 请求消息、调用所需的业务 Service 并将结果作为响应消息返回。 2.1、Spring Web Service 的测试支持 为了测试此类端点，我们可以通过传递所需的参数或模拟（Mock）来轻松创建单元测试。然而，这样做的主要缺点是无法实际测试通过网络发送的 XML 消息的内容。另一种方法是创建集成测试，以验证消息的 XML 内容。 Spring Web Service 2.0 引入了对此类端点集成测试的支持。提供这种支持的核心类是 MockWebServiceClient。它提供了一个 Fluent API，用于向 Spring Application Context 中配置的适当端点发送 XML 消息。此外，我们还可以设置响应预期、验证响应 XML，并对端点执行完整的集成测试。 不过，这需要调用整个 Application Context，从而减慢测试执行速度。这通常是不可取的，尤其是当我们希望为特定 Web Service 端点创建快速、隔离的测试时。 2.2、Spring Boot @WebServiceServerTest Spring Boot 2.6 通过 @WebServiceServerTest 注解扩展了 Web Service 测试支持。 https://springdoc.cn/spring-requestmapping-properties-file/ Thu, 26 Oct 2023 12:13:53 +0800 https://springdoc.cn/spring-requestmapping-properties-file/ 在 Spring Boot 中，我们通过 @RequestMapping 注解来定义 API 端点，如下： @RestController @RequestMapping public class DemoController { @GetMapping("/demo") public ResponseEntity<String> demo () { return ResponseEntity.ok("ok"); } } @GetMapping 是 @RequestMapping(method = RequestMethod.POST) 的快捷方式。 通过其 value 属性（path 属性的别名） 设置 API 的映射路径。 在本例中，路径就是：/demo。 启动应用，使用 cURL 进行访问。 $ curl localhost:8080/demo ok 一般来说，API 的路径不会轻易修改。而且路径是硬编码定义在注解中的，如果要修改的话，需要编辑源码重写编译打包。 但是，总有例外。如果我们想要灵活地修改 API 路径，那么可以在 @RequestMapping 中使用表达式从配置文件获取值。 先在配置文件（Properties / Yaml）中定义 API 路径： app: router: demo: "/demo/v1" 然后，在 @RequestMapping 使用 ${app.router.demo} 获取该值，作为 API 的路径： @RestController @RequestMapping public class DemoController { @GetMapping("${app. https://springdoc.cn/java-httpservletrequest-mock/ Thu, 26 Oct 2023 10:54:26 +0800 https://springdoc.cn/java-httpservletrequest-mock/ 1、概览 本文将带你了解几种模拟 HttpServletRequest 对象的方法。 首先，从 Spring Test 中的 MockHttpServletRequest 开始，这是一个功能齐全的模拟类型。然后，了解如何使用 Mockito 和 JMockit 这两个流行的模拟库进行测试。最后，了解如何使用匿名子类进行测试。 2、测试 HttpServletRequest 当我们要模拟客户端 request 信息（如 HttpServletRequest）来测试 Servlet 可能会有点麻烦，该接口定义了各种方法，需要进行实现。 要测试的目标 UserServlet 类，如下： public class UserServlet extends HttpServlet { protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException { String firstName = request.getParameter("firstName"); String lastName = request.getParameter("lastName"); response.getWriter().append("Full Name: " + firstName + " " + lastName); } } 要对 doGet() 方法进行单元测试，需要模拟 request 和 response 参数，以模拟实际的运行时行为。 3、使用 Spring 的 MockHttpServletRequest Spring-Test 提供了一个功能齐全的类 MockHttpServletRequest，它实现了 HttpServletRequest 接口。 https://springdoc.cn/openapi-jwt-authentication/ Thu, 26 Oct 2023 09:21:36 +0800 https://springdoc.cn/openapi-jwt-authentication/ 1、概览 OpenAPI 是一种与语言无关且独立于平台的规范，用于标准化 REST API。OpenAPI 使用户能够在不深入代码的情况下轻松理解 API。 Swagger-UI 根据 OpenAPI 规范生成可视化文档，帮助可视化和测试 REST API。 本文将带你了解如何在 Spring Boot 应用中使用 Springdoc-OpenAPI 生成 OpenAPI 文档、测试 REST API 并为 OpenAPI 配置 JWT Authentication（认证）。 2、Swagger-UI Swagger-UI 是 HTML、Javascript 和 CSS 文件的集合，可根据 OpenAPI 规范生成 UI 界面。 当 API 数量不断增加时，编写 OpenAPI 文档规范就变得非常具有挑战性。Springdoc-OpenAPI 可以帮助我们自动生成 OpenAPI 文档。 接下来，我们通过示例了解如何使用 Springdoc-OpenAPI 库自动生成 REST API 的 OpenAPI 文档，并使用 Swagger-UI 可视化这些 API。 2.1、依赖 首先，添加 Springdoc-OpenAPI 依赖。 <dependency> <groupId>org.springdoc</groupId> <artifactId>springdoc-openapi-ui</artifactId> <version>1.6.9</version> </dependency> 此依赖还将 Swagger-UI web-jar 添加到 Spring Boot 应用中。 https://springdoc.cn/spring-boot-requestbodyadvice-decode/ Wed, 25 Oct 2023 14:33:22 +0800 https://springdoc.cn/spring-boot-requestbodyadvice-decode/ 在一些数据比较敏感或者对安全要求比较高的应用中，客户端提交给服务器的数据需要进行加密，服务器需要解密后才能获取到原始的请求数据。 在 Spring Boot 中，可以通过 RequestBodyAdvice 对请求体进行统一的解密处理，这对 Controller 来说是完全透明的，极大地提高了应用的可维护性。 RequestBodyAdvice 接口 这是由 spring mvc 提供的一个增强接口，用于在 HttpMessageConverter 读取请求体并把它转换为 Java 对象之前进行一些操作。 public interface RequestBodyAdvice { boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType); HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException; Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType); @Nullable Object handleEmptyBody(@Nullable Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<? https://springdoc.cn/a-guide-to-versioning-apis-in-spring-boot/ Wed, 25 Oct 2023 13:35:42 +0800 https://springdoc.cn/a-guide-to-versioning-apis-in-spring-boot/ 简介 本文将带你了解 Spring Boot 应用中对 API 进行版本控制的重要性，以及不同的实现方式。 通过 API 版本控制，你可以对API进行更改，而不会破坏与现有客户端的兼容性。本文将介绍四种常见的版本控制方式：URI 版本控制、请求参数版本控制、自定义 Header 版本控制和内容协商（Accept Header）版本控制。 URI 版本控制 URI 版本控制涉及将版本号添加到 API 的 URL 中。这是一种直接而易于理解的方法。然而，它可能不是最优雅的方法，因为它可能导致URL变得很长。 示例： @RestController @RequestMapping("/api/v1/users") public class UserControllerV1 { @GetMapping public ResponseEntity<List<User>> getUsers() { // 实现代码 } // 其他端点 } 请求参数版本控制 采用这种方法时，版本号会作为请求参数传递。这种方法比 URI 版本控制更省事，但对消费者来说可能不那么直观。 示例： @RestController public class UserController { @GetMapping(value = "/api/users", params = "version=1") public ResponseEntity<List<User>> getUsersV1() { // 实现代码 } @GetMapping(value = "/api/users", params = "version=2") public ResponseEntity<List<User>> getUsersV2() { // 实现代码 } } 自定义 Header 版本控制 自定义 Header 版本控制涉及向 HTTP 请求添加一个自定义 Header，其中包含版本号。这种方法可以保持 URI 的清晰，但消费者必须记住要添加自定义 Header。 https://springdoc.cn/how-to-write-graphql-apis-in-spring-boot-a-beginners-guide/ Wed, 25 Oct 2023 12:30:14 +0800 https://springdoc.cn/how-to-write-graphql-apis-in-spring-boot-a-beginners-guide/ GraphQL 是啥？ 根据其 官方文档，“GraphQL 是一种用于 API 的查询语言，也是一种服务器端运行时，可使用你为数据定义的类型系统来执行查询”。该语言由 Meta 公司开发并开源，目前由众多公司和个人社区共同维护。 GraphQL 包括 2 个主要部分： Schema Definition Language（Schema 定义语言） - 使用 GraphQL SDL（Schema 定义语言）指定服务的 GraphQL Schema，有时也称为 GraphQL Schema 语言。 Query Language（查询语言） - 查询语言由Query、Mutation 和 Subscription 三部分组成 本文稍后会进行介绍。 GraphQL 有很多出色的功能，例如： 它实现了声明式数据获取，并提供了一个单一的端点，客户端可以准确地指定所需的信息，不再需要过度获取信息。 它提供开箱即用的验证和类型检查功能，你可以在执行前在 GraphQL 强类型系统中验证查询。 GraphQL 可以使 API 文档与 API 的更改保持同步。这对开发人员非常有益，因为他们无需花费太多时间来编写 API 文档。 GraphQL 通过在字段级别废除 API，消除了对版本控制的需求。旧字段可以在不影响现有查询的情况下从 Schema 中删除。 也有一些缺点： GraphQL 需要客户端和服务器端更多的工具支持。这需要大量的前期付出。对于非常简单的 API 用例来说，这不是一个合适的替代方案。 GrpahQL 只有一个入口，默认使用 HTTP POST。这就妨碍了客户端 HTTP 缓存的充分使用，并使得实现缓存成为一项相对复杂的任务。 GraphQL Schema GraphQL 服务必须使用 Schema。GraphQL Schema 定义了如何从服务器请求和返回数据，并由 GraphQL SDL 控制。 https://springdoc.cn/spring-keycloak-security-disable/ Wed, 25 Oct 2023 11:23:24 +0800 https://springdoc.cn/spring-keycloak-security-disable/ 1、概览 Keycloak 是一个开源的身份和访问管理解决方案。在测试阶段，禁用 Keycloak 可能有助于专注于业务测试。而且在测试环境中可能没有 Keycloak 服务器。 本文将带你了解如何禁用 Keycloak starter 的配置，以及如何在项目中启用 Spring Security 后如何对其进行修改。 2、在非 Spring Security 环境下禁用 Keycloak 我们首先来看看如何在不使用 Spring Security 的应用中禁用 Keycloak。 2.1、应用设置 首先，添加 spring-boot-starter-oauth2-client 依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-oauth2-client</artifactId> </dependency> 此外，还需要添加 spring-boot-starter-oauth2-resource-server 依赖。它将允许我们使用 Keycloak 服务器验证 JWT Token： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-oauth2-resource-server</artifactId> </dependency> 接下来，在 application.properties 中添加 Keycloak 服务器的配置： spring.security.oauth2.client.registration.keycloak.client-id=login-app spring.security.oauth2.client.registration.keycloak.authorization-grant-type=authorization_code spring.security.oauth2.client.registration.keycloak.scope=openid spring.security.oauth2.client.provider.keycloak.issuer-uri= http://localhost:8080/realms/SpringBootKeycloak spring.security.oauth2.client.provider.keycloak.user-name-attribute=preferred_username spring.security.oauth2.resourceserver.jwt.issuer-uri=http://localhost:8080/realms/SpringBootKeycloak 最后，添加 UserController 来检索用户： @RestController @RequestMapping("/users") public class UserController { @GetMapping("/{userId}") public User getCustomer(@PathVariable Long userId) { return new User(userId, "John", "Doe"); } } 2. https://springdoc.cn/spring-boot-spring-security-jwt-mysql/ Wed, 25 Oct 2023 09:48:18 +0800 https://springdoc.cn/spring-boot-spring-security-jwt-mysql/ 本文将会带你了解在 Spring Boot 中如何使用 Spring Security、JWT 和 MySQL 数据库实现基于 Token 的身份认证。 JWT （JSON Web Token）概览 JWT 是 JSON Web Token 的缩写，是一种安全地在各方之间传输信息的开放标准。它是一种紧凑、自包含的数据传输方法，通常用于客户端和服务器之间的数据传输。 JWT 通常用于认证和授权，服务器通过验证 JWT 中包含的数字签名来验证用户。 JWT 由三部分组成：Header、Payload 和 Signature（签名）。 Header 包含 Token 类型和 Token 签名算法的元数据。 Payload 包含关于被验证用户或实体的声明（Claim）或陈述。这些声明可包括用户 ID、用户名或电子邮件地址等信息。 Signature（签名）使用秘钥和 Header 及 Payload 生成，以确保 JWT 的完整性。 使用 JWT 的一个好处是它们是无状态的，这意味着服务器无需跟踪用户的身份认证状态。这可以提高可扩展性和性能。此外，JWT 可以在不同的域和服务中使用，只要它们共享相同的秘钥来验证签名即可。 Spring Security 概览 Spring Security 是一个提供身份认证、授权和防护常见攻击的框架。它为确保 Web 和响应式应用程序的安全提供一流的支持，是保护基于 Spring 的应用程序的事实标准。 Spring Security 用于保护 Web 应用程序、REST API 和微服务的安全，为身份认证和授权提供内置支持。 数据库表结构 添加 Maven 依赖 添加如下依赖到 Spring Boot 项目： https://springdoc.cn/spring-security-exceptionhandler/ Wed, 25 Oct 2023 09:09:38 +0800 https://springdoc.cn/spring-security-exceptionhandler/ 1、概览 本文将会带你了解如何使用 @ExceptionHandler 和 @ControllerAdvice 全局处理 Spring Security 异常。 Controller Advice 是一种拦截器，常用于处理全局异常。 2、Spring Security 异常 Spring Security 核心异常（如 AuthenticationException 和 AccessDeniedException）属于运行时异常。由于这些异常是由 DispatcherServlet 后面的 Authentication Filter 在调用 Controller 方法之前抛出的，因此 @ControllerAdvice 无法捕获这些异常。 通过添加自定义 Filter 和构建响应体，可以直接处理 Spring Security 异常。要通过@ExceptionHandler 和 @ControllerAdvice 在全局级别处理这些异常，需要自定义 AuthenticationEntryPoint 的实现。AuthenticationEntryPoint 用于发送 HTTP 响应，要求客户端提供凭证。虽然已经有多个内置实现，但是我们仍然需要自己实现，以发送自定义响应。 首先，让我们看看如何在不使用 @ExceptionHandler 的情况下全局处理 Security 异常。 3、不使用 @ExceptionHandler Spring Security 异常是从 AuthenticationEntryPoint 开始的。让我们编写一个 AuthenticationEntryPoint 的实现，用于拦截 Security 异常。 3.1、配置 AuthenticationEntryPoint 实现 AuthenticationEntryPoint 并覆写 commence() 方法： @Component("customAuthenticationEntryPoint") public class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint { @Override public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException { RestError re = new RestError(HttpStatus. https://springdoc.cn/spring-boot-uploaded-image-validate/ Tue, 24 Oct 2023 15:21:50 +0800 https://springdoc.cn/spring-boot-uploaded-image-validate/ 图片上传是现代应用中非常常见的一种功能，也是风险比较高的一个地方。恶意用户可能会上传一些病毒、木马。这些东西不仅严重威胁服务器的安全还浪费了带宽，磁盘等资源。所以，在图片上传的接口中，一定要对用户上传的文件进行严格的校验。 本文介绍了 2 种对图片文件进行验证的方法可供你参考。 文件后缀校验 通过文件后缀（也就是文件扩展名，通常用于表示文件的类型），进行文件类型校验这是最常见的做法。 图片文件的后缀类型有很多，常见的只有：jpg、jpeg、gif、png、webp。我们可以在配置或者代码中定义一个“允许上传的图片后缀”集合，用于校验用户上传的图片文件。 package cn.springdoc.demo.web.controller; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.Set; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.multipart.MultipartFile; @RestController @RequestMapping("/upload") public class UploadController { // 允许上传的图片类型的后缀集合 static final Set<String> imageSuffix = Set.of("jpg", "jpeg", "gif", "png", "webp"); @PostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE) public ResponseEntity<String> upload (@RequestParam("file") MultipartFile file ) throws IllegalStateException, IOException{ // 文件的原始名称 String fileName = file.getOriginalFilename(); if (fileName == null) { return ResponseEntity. https://springdoc.cn/spring-bean-name-refuse-to-be-proxied/ Tue, 24 Oct 2023 15:06:38 +0800 https://springdoc.cn/spring-bean-name-refuse-to-be-proxied/ 一些使用小细节就是在不断的源码探索中逐步发现的，今天就来和大家研究一下通过 beanName 的设置，可以让一个 bean 拒绝被代理的问题！ 1. 代码实践 假设我有如下一个切面： @Aspect @EnableAspectJAutoProxy @Component public class LogAspect { @Pointcut("execution(* org.javaboy.demo.service.*.*(..))") public void pc() { } @Before("pc()") public void before(JoinPoint jp) { String name = jp.getSignature().getName(); System.out.println(name + " 方法开始执行了..."); } } 这个切面要拦截的方法是 org.javaboy.demo.service 包下的所有类的所有方法，现在，这个包下有一个 BookService 类，内容如下： @Service("org.javaboy.demo.service.BookService.ORIGINAL") public class BookService { public void hello() { System.out.println("hello bs"); } } 这个 BookService 的 beanName 我没有使用默认的 beanName，而是自己配置了一个 beanName，这个 beanName 的配置方式是 类名的完整路径 + .ORIGINAL。 当我们按照这样的规则给 bean 取名之后，那么即使当前 bean 已经包含在切点所定义的范围内，这个 bean 也不会被代理了。 https://springdoc.cn/spring-cloud-gateway-response-body/ Tue, 24 Oct 2023 10:29:02 +0800 https://springdoc.cn/spring-cloud-gateway-response-body/ 1、简介 本文将带你了解如何在 Spring Cloud Gateway 中读取、修改响应体，然后再响应给客户端。 2、Spring Cloud Gateway 快速回顾 Spring Cloud Gateway（简称 SCG）是 Spring Cloud 系列中的一个子项目，它提供了一个构建在响应式 Web 栈之上的 API 网关。关于它的更多详细信息和用法，你可以参考 官方文档。 设计 API Gateway 解决方案时经常出现的一种特殊使用场景：如何在将后端响应的 Body 发送回客户端之前对其进行处理？ 下面列出了一些可能会用到这种功能的场景： 保持与现有客户端的兼容性，同时允许后台不断迭代 需要屏蔽响应中的某些敏感字段（脱敏） 实现这个需求，只需要实现一个 Filter 来处理后台响应即可。Filter 是 SCG 的核心概念。 Filter 组件创建后就可以将其应用于任何已声明的路由（Route）。 3、实现数据过滤 Filter 创建一个简单的 Filter 来屏蔽 JSON 响应中的某些值。 例如，给定的 JSON 有一个名为 “ssn” 的字段： { "name" : "John Doe", "ssn" : "123-45-9999", "account" : "9999888877770000" } 我们希望用一个固定的值进行替换，从而防止数据泄漏： { "name" : "John Doe", "ssn" : "****", "account" : "9999888877770000" } 3. https://springdoc.cn/spring-same-class-multiple-beans/ Tue, 24 Oct 2023 09:50:28 +0800 https://springdoc.cn/spring-same-class-multiple-beans/ 1、概览 Spring IoC 容器创建和管理 Spring Bean，这些 Bean 是应用的核心。创建一个 Bean 实例与从普通的 Java 类创建对象相同。然而，生成多个相同类的 Bean 可能会比较麻烦一点。 本文将带你了解如何在 Spring 中使用注解创建同一个类的多个 Bean。 2、使用 Java 配置 这是使用注解创建多个同类 Bean 的最简单易行的方法。 举一个简单的例子。我们有一个 Person 类，它有两个字段：firstName 和 lastName： public class Person { private String firstName; private String lastName; public Person(String firstName, String secondName) { super(); this.firstName = firstName; this.lastName = secondName; } @Override public String toString() { return "Person [firstName=" + firstName + ", secondName=" + lastName + "]"; } } 接下来，构建一个名为 PersonConfig 的配置类，并在其中定义 Person 类的多个 Bean： https://springdoc.cn/spring-boot-redis-testcontainers/ Tue, 24 Oct 2023 09:04:13 +0800 https://springdoc.cn/spring-boot-redis-testcontainers/ 1、概览 Testcontainers 是一个用于创建临时 Docker 容器进行单元测试的 Java 库。当我们想要避免使用实际服务器进行测试时，它非常有用。 本文将会带你了解如何在 Spring Boot 中使用 Testcontainers 测试 Redis。 2、项目设置 使用任何测试容器的首要前提是在运行测试的机器上安装 Docker。 安装好 Docker 后，就可以开始设置 Spring Boot 应用了。 在此应用中，我们将设置一个 Redis Hash、一个 Repository 和一个使用 Repository 与 Redis 交互的 Service。 2.1、依赖 添加所需的 spring-boot-starter-test 和 spring-boot-starter-data-redis 依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 接着，还要添加 Testcontainers 依赖： <dependency> <groupId>org.testcontainers</groupId> <artifactId>testcontainers</artifactId> <version>1.17.2</version> <scope>test</scope> </dependency> 2.2、配置 在 application.properties 文件中添加 Redis 连接的详细信息： spring.redis.host=127.0.0.1 spring.redis.port=6379 3、应用设置 我们要创建一个小型应用，向 Redis 数据库读写 Product（产品）。 3.1、Entity 创建 Product 类。 https://springdoc.cn/spring-boot-keycloak-integration-testing/ Mon, 23 Oct 2023 19:12:09 +0800 https://springdoc.cn/spring-boot-keycloak-integration-testing/ 1、简介 通常我们会通过集成测试来验证应用功能是否正常。集成测试至关重要，特别是对于认证这种敏感且重要的功能。Testcontainers 允许在测试阶段启动 Docker 容器，以便对实际的技术栈运行测试。 本文将带你了解如何使用 Testcontainers 针对实际的 Keycloak 实例设置集成测试。 2、配置 Spring Security 和 Keycloak 我们需要配置 Spring Security、Keycloak 和 Testcontainers。 2.1、整合 Spring Boot 和 Spring Security 在 pom.xml 中添加 spring-boot-starter-security 依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> 接着，创建一个示例 Controller，它返回一个 User。 @RestController @RequestMapping("/users") public class UserController { @GetMapping("me") public UserDto getMe() { return new UserDto(1L, "janedoe", "Doe", "Jane", "jane.doe@baeldung.com"); } } 至此，我们有了一个受保护的 Controller，用于处理对 /users/me 端点的请求。启动应用时，Spring Security 会为用户 user 生成一个密码，该密码在控制台输出的日志中。 2.配置 Keycloak 启动本地 Keycloak 的最简单方法是使用 Docker。 https://springdoc.cn/java-notnull-method-parameter/ Mon, 23 Oct 2023 08:44:16 +0800 https://springdoc.cn/java-notnull-method-parameter/ 1、概览 空指针异常 NullPointerException 是一个常见问题，避免这种问题的方法之一是在方法参数上添加 @NotNull 等校验注解。 给方法参数添加了 @NotNull 注解后，还需要其他的一些设置才能自动对参数进行非空校验。 2、给方法参数添加 @NotNull 注解 创建一个类，其中包含一个返回 String 长度的方法。 在 String 参数上添加 @NotNull 注解： public class NotNullMethodParameter { public int validateNotNull(@NotNull String data) { return data.length(); } } 注意，有多个包下都有 @NotNull 注解，我们使用的应该是 jakarta.validation.constraints 包。 创建 NotNullMethodParameter 实例，然后使用 null 参数调用方法。 NotNullMethodParameter notNullMethodParameter = new NotNullMethodParameter(); notNullMethodParameter.doesNotValidate(null); 尽管在参数上使用了 @NotNull，但还是出现了空指针异常：NullPointerException。 注解未生效，因为没有 Validator 来执行它。 3、添加 Validator 添加 Hibernate Validator（jakarta.validation 的实现）来识别 @NotNull。 <dependency> <groupId>org.hibernate.validator</groupId> <artifactId>hibernate-validator</artifactId> <version>8.0.0.Final</version> </dependency> 使用默认的 ValidatorFactory 创建 validator。 https://springdoc.cn/spring-boot-static-resource/ Sun, 22 Oct 2023 17:13:27 +0800 https://springdoc.cn/spring-boot-static-resource/ Spring Boot 对静态资源提供了支持。默认情况下，以下目录为默认的静态资源目录。其中的静态资源可以被直接访问： classpath:/META-INF/resources/ classpath:/resources/ classpath:/static/ classpath:/public/ ${user.dir}/public/ （程序运行目录下的 public 目录） 优先级从上往下，当多个静态资源目录中出现同名文件时，越靠上的目录权重越高。 静态资源的处理类是 ResourceHttpRequestHandler，它会正确地处理资源的 Last-Modified 响应和 Range 请求。 静态资源和 RequestMapping 冲突 如果静态资源路径和 @RequestMapping 路径冲突，则 @RequestMapping 优先。 例如，有如下 Controller： @RestController @RequestMapping public class DemoController { @GetMapping("/foo") public ResponseEntity<String> foo () { // 返回字符串 “controller” return ResponseEntity.ok("controller"); } } 在 src/main/resources/public 目录下有一个名为 foo 的文本文件，内容如下： public 启动应用，访问 http://localhost:8080/foo： $ curl http://localhost:8080/foo controller 你可以看到，响应的内容是 controller，说明 controller 的 @RequestMapping 优先。 另外，对于这种没有后缀、未知类型的静态资源，Spring Boot 会以 “下载” 的形式响应给客户端（添加了 Content-Disposition 响应头）。 https://springdoc.cn/spring-openapi-global-securityscheme/ Sun, 22 Oct 2023 15:34:18 +0800 https://springdoc.cn/spring-openapi-global-securityscheme/ 1、概览 本文将带你了解如何在 Spring MVC Web 应用中使用 springdoc-openapi 配置默认的全局 Security Scheme，并将其应用为 API 的默认安全配置，以及如何覆盖这些默认的安全配置。 OpenAPI 规范 允许为 API 定义一套 Security Scheme。可以配置 API 全局的安全配置，也可以按端点应用/删除安全配置。 2、设置 构建一个 Spring Boot Web 项目，使用 Maven。 2.1、依赖 该示例有两个依赖。第一个是 spring-boot-starter-web，用于构建 Web 应用。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.7.1</version> </dependency> 另一个依赖是 springdoc-openapi-ui，它用于输出 HTML、JSON 或 YAML 格式的 API 文档： <dependency> <groupId>org.springdoc</groupId> <artifactId>springdoc-openapi-ui</artifactId> <version>1.6.9</version> </dependency> 2.2、启动类 使用 @SpringBootApplication 注解来定义启动类，通过 SpringApplication 类来启动应用： @SpringBootApplication public class DefaultGlobalSecuritySchemeApplication { public static void main(String[] args) { SpringApplication.run(DefaultGlobalSecuritySchemeApplication.class, args); } } 3、springdoc-openapi 基础配置 配置好 Spring MVC 后，来看看 API 语义信息。 https://springdoc.cn/spring-reactive-read-flux-into-inputstream/ Sun, 22 Oct 2023 14:31:40 +0800 https://springdoc.cn/spring-reactive-read-flux-into-inputstream/ 1、概览 本文将会带你了解在 Java 响应式编程中如何将 Flux<DataBuffer> 读取到 InputStream。 2、请求设置 首先，使用 Spring Reactive WebClient 发起 GET 请求。使用由 gorest.co.in 托管的公共 API 端点来进行测试： String REQUEST_ENDPOINT = "https://gorest.co.in/public/v2/users"; 接下来，定义 getWebClient() 方法，用于获取 WebClient 类的新实例： static WebClient getWebClient() { WebClient.Builder webClientBuilder = WebClient.builder(); return webClientBuilder.build(); } 至此，我们就可以向 /public/v2/users 端点发出 GET 请求了。注意，必须以 Flux<DataBuffer> 对象的形式获取响应体。 3、BodyExtractors 和 DataBufferUtils 我们可以使用 spring-webflux 中 BodyExtractors 类的 toDataBuffers() 方法将响应体提取到 Flux<DataBuffer> 中。 将 body 构建为 Flux<DataBuffer> 类型的实例： Flux<DataBuffer> body = client .get( .uri(REQUEST_ENDPOINT) .exchangeToFlux( clientResponse -> { return clientResponse. https://springdoc.cn/java-graalvm-docker-image/ Sun, 22 Oct 2023 13:42:19 +0800 https://springdoc.cn/java-graalvm-docker-image/ 1、简介 GraalVM 使用其 Ahead-Of-Time（AOT）编译器将 Java 应用程序编译为机器可执行文件。这些可执行文件直接在目标机器上执行，而无需使用即时编译器 （JIT）。GraalVM生成的二进制文件体积较小，启动速度快，并且在没有任何预热的情况下提供最佳性能。此外，这些可执行文件相比在 JVM 上运行的应用程序而言，内存占用和 CPU 使用率较低。 通过 Docker，我们可以将软件组件打包成 Docker Image，并作为 Docker 容器运行。Docker 容器包含应用程序运行所需的一切，包括应用程序代码、运行时、系统工具和库。 在本教程中，我们将了解如何创建 Java 应用程序的 GraalVM 原生（native）镜像，以及如何将该原生镜像用作 Docker 镜像，并将其作为 Docker 容器运行。 2、原生镜像是什么？ 原生镜像（Native Image）是一种将 Java 代码提前编译成原生可执行文件的技术。该原生可执行文件只包含运行时需要执行的代码。这包括应用程序类、标准库类、语言运行时和 JDK 中静态链接的本地代码。 原生镜像生成器（Native Image Builder）会扫描应用程序类和其他元数据，以创建一个特定于操作系统和体系结构的二进制文件。本地镜像工具会执行静态应用程序代码分析，以确定应用程序运行时可访问的类和方法。然后，它将所需的类、方法和资源编译成二进制可执行文件。 3、原生镜像的优点 原生镜像可执行文件有几个好处： 由于原生镜像生成器只编译运行时所需的资源，因此可执行文件的体积很小 本地可执行文件的启动时间极短，因为它们是在目标机器中直接执行的，无需使用 JIT 编译器 由于只打包所需的应用程序资源，暴漏的攻击面较小 将其打包为轻量级容器镜像（如 Docker Image），有助于快速高效地部署 4、构建 GraalVM 原生镜像 在本节中，我们将为 Spring Boot 应用构建 GraalVM 原生镜像。首先，需要安装 GraalVM 并设置 JAVA_HOME 环境变量。其次，创建一个包含 Spring Web 和 GraalVM Native Support 依赖的 Spring Boot 应用： https://springdoc.cn/spring-boot-mysql-backup/ Sat, 21 Oct 2023 19:16:57 +0800 https://springdoc.cn/spring-boot-mysql-backup/ 应用系统中最重要的东西就是 “数据”，定期备份数据的重要性就不言而喻了。本文将会带你了解如何在 Spring Boot 应用中实现定期备份 MySQL 数据库。 mysqldump MYSQL本身提供了一个工具 mysqldump，通过它可以完成数据库的备份。 简单来说就是一个命令，可以把数据库中的表结构和数据，以 SQL 语句的形式输出到标准输出： mysqldump -u[用户名] -p[密码] [数据库] > [备份的SQL文件] 注意，命令中的 > 符号在linux下是重定向符，在这里的意思就是把标准输出重定向到文件。 例如，备份 demo 库到 ~/mysql.sql，用户名和密码都是 root： mysqldump -uroot -proot demo > ~/mysql.sql mysqldump 的详细文档：https://dev.mysql.com/doc/refman/en/mysqldump.html 创建应用 创建任意 Spring Boot 应用，并添加 commons-exec 依赖。 <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-exec --> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-exec</artifactId> <version>1.3</version> </dependency> 由于我们的备份是通过新启动一个子进程调用 mysqldump 来完成，所以建议使用 apache 的 commons-exec 库。它的使用比较简单，且设计合理，包含了子进程超时控制，异步执行等等功能。 应用配置 spring: # 基本的数据源配置 datasource: type: com.zaxxer.hikari.HikariDataSource driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2b8&allowMultiQueries=true username: root password: root app: # 备份配置 backup: # 备份数据库 db: "demo" # 备份文件存储目录 dir: "backups" # 备份文件最多保留时间。如，5分钟：5m、12小时：12h、1天：1d max-age: 3m 如上，我们配置了基本的数据源。以及自定义的 “备份配置”，其中指定了备份文件的存储目录，要备份的数据库以及备份文件滚动存储的最大保存时间。 https://springdoc.cn/spring-boot-validate-boolean-type/ Sat, 21 Oct 2023 09:44:13 +0800 https://springdoc.cn/spring-boot-validate-boolean-type/ 1、简介 在本文中，我们将学习如何在 Spring Boot 中的不同层（如 controller 或 service）上验证布尔（Boolean）类型以及执行验证的各种方式。 2、编程式验证 Boolean 类提供了两个创建该类实例的基本方法：Boolean.valueOf() 和 Boolean.parseBoolean()。 Boolean.valueOf() 可接受 String 和 boolean 值。它会检查输入参数的值是 true 还是 false，并相应地提供一个 Boolean 对象。Boolean.parseBoolean() 方法只接受 String 值。 这些方法不区分大小写，例如，true、True、TRUE、false 和 FALSE 都是可以的。 通过单元测试来验证 String 到 Boolean 的转换： @Test void givenInputAsString_whenStringToBoolean_thenValidBooleanConversion() { assertEquals(Boolean.TRUE, Boolean.valueOf("TRUE")); assertEquals(Boolean.FALSE, Boolean.valueOf("false")); assertEquals(Boolean.TRUE, Boolean.parseBoolean("True")); } 验证从基本 boolean 值到 Boolean 封装类的转换： @Test void givenInputAsboolean_whenbooleanToBoolean_thenValidBooleanConversion() { assertEquals(Boolean.TRUE, Boolean.valueOf(true)); assertEquals(Boolean.FALSE, Boolean.valueOf(false)); } 3、使用自定义 Jackson Deserializer 进行验证 Spring Boot API 经常需要处理 JSON 数据，我们还要了解如何通过数据反序列化验证 JSON 到 Boolean 值的转换。我们可以使用自定义 deserializer 反序列化 boolean 值的自定义表示。 https://springdoc.cn/apache-kafkas-exactly-once-semantics-in-spring-cloud-stream-kafka/ Sat, 21 Oct 2023 08:34:57 +0800 https://springdoc.cn/apache-kafkas-exactly-once-semantics-in-spring-cloud-stream-kafka/ 在之前的教程中，我们对 Spring Cloud Stream Kafka 应用程序中事务的工作原理进行了基本分析。现在，我们终于来到了一个关键问题：“仅一次” （Exactly Once）语义，这是流式应用程序中一个被广泛讨论和需要的特性。在本文中，我们将了解如何通过 Apache Kafka 事务在 Spring Cloud Stream 应用中实现 “仅一次” 语义。通过之前章节对事务工作原理的了解，相对容易理解 Spring Cloud Stream Kafka 应用如何实现 “仅一次” 语义。 这里需要注意的一点是，在实现 “仅一次” 语义时，除了我们在之前的系列教程文章中已经见过的代码，我们无需编写任何新的代码。本文介绍了在 Spring Cloud Stream Kafka 应用程序中支持 “仅一次” 语义所需的特定要求。 在分布式计算中实现 “仅一次” 语义是一项困难的任务。这超出了本系列教程的范围，在这里无法回顾所有技术细节，以了解为什么这是一项如此困难的任务。对于有兴趣了解 “仅一次” 语义的所有基础知识以及为什么在分布式系统中实现它如此困难的读者，可以参考相关的广泛文献。Confluent 的这篇 博客 是理解这些技术挑战以及 Apache Kafka 实现的解决方案的良好起点。 虽然我们不会深入探讨细节，但看看 Apache Kafka 提供的不同交付保证还是值得的。主要有三种交付保证： 至少一次（at-least-once） 最多一次（at-most-once） 仅一次（exactly-once） 在 “至少一次” 的交付语义中，应用程序可以一次或多次接收数据，但保证至少接收一次。在 “最多一次” 语义的交付保证中，应用程序可能接收零次或一次数据，这意味着有可能丢失数据。“仅一次” 语义，正如其名称所示，保证只交付一次。根据应用程序的使用情况，使用其中任何一种保证都是可以的。默认情况下，Apache Kafka 提供至少一次交付保证，这意味着一条记录可能会被交付多次。如果你的应用程序可以处理重复记录或无记录的后果，那么使用非一次保证可能也没问题。相反，如果你处理的是关键任务数据，如金融系统或医疗数据，你就必须保证 “仅一次” 准确交付和处理，以避免严重后果。由于 Apache Kafka 等系统的分布式特性，通常很难实现精确的 “仅一次” 语义，这是因为系统中存在许多部件。 Spring Cloud Stream Kafka 和 Exactly-Once 语义 在本教程系列的前几篇文章中，我们看到了许多不同的应用场景。Apache Kafka 中的 “仅一次” 义针对的是读-处理-写（或消费-转换-生产）应用。有时，我们会对 “一次” 到底在做什么感到困惑。是最初的消费、数据处理，还是最后的生产？Apache Kafka 保证整个 “读取->处理-写入”（read->process-write）序列的 “仅一次”（actly-once）语义。在这个序列中，读取和处理部分总是至少一次 - 例如，如果部分处理或写入因任何原因失败。如果依赖 “仅一次” 交付，事务就非常关键，这样才能成功完成或回滚数据的最终发布。一个潜在的副作用是，初始消费和处理可能会发生多次。例如，如果事务回滚，消费者偏移量不会更新，下一次轮询（如果是在 Spring Cloud Stream 中重试或应用程序重启）将重新交付相同的记录并再次进行处理。因此，在消费和处理（转换）部分中至少保证一次，这是需要理解的关键点。任何以 read_committed 隔离级别运行的下游消费者都只能从上游处理器获得一次信息。因此，我们必须明白，在 “仅一次” 交付的世界中，处理器和下游消费者必须协调才能从精确一次语义中获益。任何以 read_uncommitted 隔离级别运行的已生成主题的消费者都可能看到重复的数据。 https://springdoc.cn/transactional-rollback-strategies-with-spring-cloud-stream-and-apache-kafka/ Fri, 20 Oct 2023 19:44:58 +0800 https://springdoc.cn/transactional-rollback-strategies-with-spring-cloud-stream-and-apache-kafka/ 在本系列教程的前几章中，我们分析了事务在 Spring Cloud Stream Kafka 应用中的工作原理。了解了事务发挥作用的不同环境，包括生产者和消费者应用，以及应用如何正确使用事务。现在，这些基本要素已经介绍完毕，让我们继续了解事务的另一个方面：在发生错误时回滚事务。当错误发生时，事务处理系统无法提交事务，事务管理器就会回滚事务，不会为下游消费者保留任何内容。如果应用能够决定回滚机制的工作方式，将大有裨益。Spring Cloud Stream 通过 Spring 对 Apache Kafla 的基本支持，为回滚定制提供了便利。在处理生产者和消费者（消费-处理-生产）事务性应用时，我们必须注意一些事情。接下来，让我们一起深入了解这些内容。 生产者发起的事务 下面是我们在 上一篇文章 中看到的代码片段。 @Transactional public void send(StreamBridge streamBridge) { for (int i = 0; i < 5; i++) { streamBridge.send("mySupplier-out-0", "my data: " + i); } } 如果事务方法抛出异常，我们应该怎么办？从 Spring Cloud Stream 的角度来看，我们不需要做任何操作。事务拦截器会启动回滚，最终由 Kafka 中的事务协调器中断事务。最后，异常会传播给调用者，然后调用者可以决定在错误是暂时的情况下重新触发事务方法。由于这是一个生产者发起的事务，框架不会进行重试。这种情况很简单，因为在事务回滚期间，从应用或框架的角度来看，我们不需要做任何操作。如果发生错误，它将被保证回滚。然而，需要注意的是，即使事务被回滚，Kafka 日志中可能存在未提交的记录。使用隔离级别为 read_uncommitted（默认级别）的消费者仍然会接收这些记录。因此，消费者应用程序必须确保使用 read_committed 隔离级别，这样才不会收到上游事务回滚的任何记录。 生产者发起的事务与外部事务同步 在本系列教程的上一章，我们看到了这种情况。与第一种情况一样，如果方法抛出异常并发生回滚，即使 Kafka 事务与数据库事务同步，应用也无需做任何事情来处理错误。数据库和 Kafka 发布的事务都会回滚。 消费者发起的事务回滚 如果生产者发起的事务回滚是如此简单，你可能会想知道为什么我们要专门为这个主题撰写一篇完整的文章。什么时候应用程序需要提供特定的回滚策略呢？当你有一个正在进行的消费者发起的事务时，这就有了意义，因为我们需要特别关注如何处理消费记录的状态和它们的偏移量。让我们重新看一下在系列中 之前的教程 中运行的消费者发起的事务方法代码。 public Consumer<PersonEvent> process(TxCode txCode) { return txCode::run; } @Component class TxCode { @Transactional void run(PersonEvent pe) { Person person = new Person(); person. https://springdoc.cn/synchronizing-with-external-transaction-managers-in-spring-cloud-stream/ Fri, 20 Oct 2023 13:27:37 +0800 https://springdoc.cn/synchronizing-with-external-transaction-managers-in-spring-cloud-stream/ 在本系列教程的 上一章，我们了解了事务管理的基本知识，主要是在使用生产者启动的 Spring Cloud Stream Kafka 应用时。上文还简要了解了 Spring Cloud Stream Kafka 消费者应用如何通过适当的隔离级别来消费以事务方式生成的记录。当你与外部事务管理器（如关系数据库的事务管理器）同步时，有提到你必须使用事务来确保数据完整性。在本教程中，我们将了解在使用外部事务管理器时，如何在 Spring Cloud Stream 中实现事务保证。 注意，实现分布式事务在实践中是非常困难的。你必须依靠两阶段提交（2PC）策略和适当的分布式事务管理器（如与 JTA 兼容的事务管理器）才能正确实现这一目标。尽管如此，大多数企业用例可能并不需要这种复杂程度，而且我们考虑的大多数用例以及人们在实践中使用的大多数用例，最好还是坚持使用非分布式事务方法，正如我们在本教程中所描述的那样。这篇文章 是 Spring 团队的 Dave Syer 博士在 2009 年发表的，对于理解分布式事务的挑战和 Spring 中推荐的替代方法，这篇文章（即使已经过去了 14 年）仍然具有现实意义。 回到我们的主题：在生产者启动和消费-处理-生产（读-处理-写）应用中使用外部事务管理器时，在 Spring Cloud Stream Kafka 应用中实现事务性。 现在，通过示例进行说明。使用 domain 对象来驱动演示，并为它们创建了伪代码。 假设消息系统处理的是 “event” domain 类型 - 让我们使用 PersonEvent： class PersonEvent { String name; String type; // 为简洁起见，其余部分省略 } 还需要为 Person 对象创建一个 Domain Entity： @Entity @Table(name = "person") public class Person { @Id @GeneratedValue(strategy = GenerationType. https://springdoc.cn/producer-initiated-transactions-in-spring-cloud-stream-kafka-applications/ Fri, 20 Oct 2023 09:44:58 +0800 https://springdoc.cn/producer-initiated-transactions-in-spring-cloud-stream-kafka-applications/ 本文是系列教程的第 2 部分，在这一部分中，我们将通过 Spring Cloud Stream 和 Apache Kafka 详细介绍事务。在 上一节 中，我们了解了事务的基本概念。本文将深入了解一些实现细节。 在本文中，我们主要从生产者的角度来了解事务如何与 Spring Cloud Stream 和 Apache Kafka 配合使用。 Spring Cloud Stream 中的生产者 在深入了解生产者发起的事务之前，我们先来了解一下简单生产者的基本知识。在 Spring Cloud Stream 中，有几种编写生产者（在消息传递领域也称为发布者）的方法。如果你的用例需要定时生成数据，你可以编写一个 java.util.function.Supplier 方法，如下所示。 @Bean public Supplier<Pojo> mySupplier() { return () -> { new Pojo(); }; } 如代码所示，将上述 Supplier 作为 Spring Bean 提供时，Spring Cloud Stream 会将其视为发布者，由于我们在 Apache Kafka 的上下文中，因此它会将 POJO 记录发送到 Kafka Topic。 默认情况下，Spring Cloud Stream 每秒调用一次 Supplier，但你可以通过配置更改该计划。更多详情，请参阅 参考文档。 如果你不想轮询 Supplier，但又想控制其发布频率，该怎么办？Spring Cloud Stream 通过名为 StreamBridge 的开箱即用实现 StreamOperations API 提供了一种便捷的方法。下面是一个示例。 https://springdoc.cn/introduction-to-transactions-in-spring-cloud-stream-kafka-applications/ Thu, 19 Oct 2023 11:05:52 +0800 https://springdoc.cn/introduction-to-transactions-in-spring-cloud-stream-kafka-applications/ 本系列教程重点介绍如何在 Spring Cloud Stream Kafka 应用中处理事务。涵盖了使用 Spring Cloud Stream 和 Apache Kafka 开发事务应用的许多底层细节。 基本组成 Spring Cloud Stream Kafka 应用中事务的基础支持主要来自于 Apache Kafka 本身和 Spring for Apache Kafka 库。然而，这个博客系列是关于如何在 Spring Cloud Stream 中使用这种支持。如果你熟悉 Apache Kafka 中的事务原理，以及 Spring for Apache Kafka 是如何以 Spring 的方式使用它的，那么这个系列将感觉像是自己的领域。 Apache Kafka 提供了基础事务支持，而 Spring for Apache Kafka（又称 Spring Kafka）库则在 Spring 侧扩展了这一支持，使 Spring 开发人员可以更自然地依赖 Spring Framework 中提供的传统事务支持来使用它。Spring Cloud Stream 中的 Kafka Binder（绑定器）进一步加强了 Spring 对 Apache Kafka 的支持，使在 Spring Cloud Stream Kafka 应用中使用相同的支持成为可能。在本系列教程的第一部分中，将简要介绍 Kafka 事务、一些有助于依赖事务的用例分析，以及 Apache Kafka 和 Spring 生态系统中的事务构建模块。 https://springdoc.cn/spring-lifecycle-and-smartlifecycle/ Wed, 18 Oct 2023 19:59:51 +0800 https://springdoc.cn/spring-lifecycle-and-smartlifecycle/ 当我们想在 Spring 容器启动或者关闭的时候，做一些初始化操作或者对象销毁操作，我们可以怎么做？ 注意我这里说的是容器启动或者关闭的时候，不是某一个 Bean 初始化或者销毁的时候！ 1、Lifecycle 对于上面提到的问题，如果你稍微研究过 Spring，应该是了解其里边有一个 Lifecycle 接口，通过这个接口，我们可以在 Spring 容器启动或者关闭的时候，做一些自己需要的事情。 我们先来看下 Lifecycle 接口： public interface Lifecycle { void start(); void stop(); boolean isRunning(); } 这个接口一共就三个方法： start：启动组件，该方法在执行之前，先调用 isRunning 方法判断组件是否已经启动了，如果已经启动了，就不重复启动了。 stop：停止组件，该方法在执行之前，先调用 isRunning 方法判断组件是否已经停止运行了，如果已经停止运行了，就不再重复停止了。 isRunning：这个是返回组件是否已经处于运行状态了，对于容器来说，只有当容器中的所有适用组件都处于运行状态时，这个方法返回 true，否则返回 false。 如果我们想自定义一个 Lifecycle，方式如下： @Component public class MyLifeCycle implements Lifecycle { private volatile boolean running; @Override public void start() { running = true; System.out.println("start"); } @Override public void stop() { running = false; System.out.println("stop"); } @Override public boolean isRunning() { return running; } } 需要自定义一个 running 变量，该变量用来描述当前组件是否处于运行/停止状态，因为系统在调用 start 和 stop 方法的时候，都会先调用 isRunning 方法，用以确认是否需要真的调用 start/stop 方法。 https://springdoc.cn/spring-boot-redis-kepp-ttl/ Wed, 18 Oct 2023 09:23:42 +0800 https://springdoc.cn/spring-boot-redis-kepp-ttl/ 在 Spring Boot 中使用 Redis 时，你一定需要过这种需求：更新某个 Redis 的 Value 值，但是不修改它的 TTL（Time To Live），也就是过期时间。 例如：使用 Redis 存储用户的 Session，过期时间为半个小时。用户的每次访问，我们都需要更新用户 Session 的 Value 值，表示用户的最后一次访问时间。但是又不能修改用户 Session 的过期时间。 有 2 种方式可以实现。 先获取过期时间，再修改 这种方式最简单，也是最容易想到。在执行修改前，先获取到这个 Key 的剩余过期时间。然后通过 SET 命令执行修改，也就是完全覆盖这个 Key / Value，同时指定剩余的过期时间。 @Autowired StringRedisTemplate stringRedisTemplate; @Test public void test() { // session key String key = "session::01"; // 先获取 key 的过期时间，单位是秒 Long expire = this.stringRedisTemplate.getExpire(key); if (expire != null && expire > 0) { // 重新设置 key，并且指定过期时间 this. https://springdoc.cn/spring-jms-testing/ Sun, 15 Oct 2023 16:04:14 +0800 https://springdoc.cn/spring-jms-testing/ 1、概览 在本文中，我们将创建一个简单的 Spring 应用，用于连接到 ActiveMQ 并发送和接收消息。我们将重点关注测试这个应用以及测试 Spring JMS 的不同方法。 Spring JMS 是 Spring 框架提供的一个模块，用于支持与 Java 消息服务（Java Message Service，JMS）提供者的集成。JMS是一种用于在分布式系统中发送、接收和传递消息的标准 API。 2、应用设置 首先，创建一个用于测试的基本 Spring 应用。添加必要的依赖，并实现消息处理。 2.1、依赖 在 pom.xml 中添加所需的依赖。我们需要 Spring JMS 来监听 JMS 消息。我们将在部分测试中使用 ActiveMQ-Junit 启动嵌入式 ActiveMQ 实例，并在其他测试中使用 TestContainers 运行 ActiveMQ Docker 容器： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jms</artifactId> <version>4.3.4.RELEASE</version> </dependency> <dependency> <groupId>org.apache.activemq.tooling</groupId> <artifactId>activemq-junit</artifactId> <version>5.16.5</version> <scope>test</scope> </dependency> <dependency> <groupId>org.testcontainers</groupId> <artifactId>testcontainers</artifactId> <version>1.17.3</version> <scope>test</scope> </dependency> 2.2、应用代码 现在，创建一个可以监听消息的 Spring 应用： @ComponentScan public class JmsApplication { public static void main(String[] args) { ApplicationContext context = new AnnotationConfigApplicationContext(JmsApplication. https://springdoc.cn/spring-spy-vs-spybean/ Sun, 15 Oct 2023 15:28:01 +0800 https://springdoc.cn/spring-spy-vs-spybean/ 1、简介 本文将带你了解 @Spy 和 @SpyBean 之间的区别和用法。 2、基本应用 本文中，我们使用一个简单的订单应用，其中包括一个用于创建订单的订单服务，以及一个用于在处理订单时发出通知的通知服务。 OrderService 有一个 save() 方法，用于接收 Order 对象，使用 OrderRepository 保存该对象，并调用 NotificationService： @Service public class OrderService { public final OrderRepository orderRepository; public final NotificationService notificationService; public OrderService(OrderRepository orderRepository, NotificationService notificationService) { this.orderRepository = orderRepository; this.notificationService = notificationService; } public Order save(Order order) { order = orderRepository.save(order); notificationService.notify(order); if(!notificationService.raiseAlert(order)){ throw new RuntimeException("Alert not raised"); } return order; } } 为简单起见，我们假设 notify() 方法仅在日志中输出订单信息。实际上，它可能涉及更复杂的操作，例如通过队列向下游应用发送电子邮件或消息。 我们还假设，每个创建的订单都必须通过调用 ExternalAlertService 来接收警报（Alert），如果警报成功，则返回 true，如果 OrderService 没有发出警报，则会失败： https://springdoc.cn/spring-rsocket/ Sun, 15 Oct 2023 07:54:22 +0800 https://springdoc.cn/spring-rsocket/ 1、概览 本文将带你了解如何在 Spring 6 中使用 RSocket。 随着 Spring 6 引入声明式 RSocket 客户端，使用 RSocket 变得更加简单。这一功能消除了重复的模板代码，使开发人员能够更高效地使用 RSocket。 2、Maven 依赖 首先，创建 Spring Boot 项目，并在 pom.xml 文件中添加 spring-boot-starter-rsocket 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-rsocket</artifactId> <version>3.1.4</version> </dependency> 3、创建 RSocket Server 首先，创建一个 responder（应答器），通过 Controller 来管理传入的请求： @MessageMapping("MyDestination") public Mono<String> message(Mono<String> input) { return input.doOnNext(msg -> System.out.println("Request is:" + msg + ",Request!")) .map(msg -> msg + ",Response!"); } 接着，在 application.properties 文件中添加以下属性，以在 7000 端口启动服务（ MyDestination）： spring.rsocket.server.port=7000 4、客户端 现在，开发客户端。为了简单起见，我们在同一个项目中创建客户端，但将其放在一个单独的包中。实际开发中，它们应该放在一个单独的项目中。 创建客户端接口： public interface MessageClient { @RSocketExchange("MyDestination") Mono<String> sendMessage(Mono<String> input); } 在使用客户端接口时，通过 @RSocketExchange 来指定 RSocket 端点。基本上，这意味着我们需要一些信息来建立端点路径。可以在接口级别上通过分配一个共享路径来实现。这非常简单，帮助我们知道要使用哪个端点。 https://springdoc.cn/springrunner-vs-springboottest/ Sun, 15 Oct 2023 07:32:43 +0800 https://springdoc.cn/springrunner-vs-springboottest/ 1、概览 无论是单元测试还是集成测试，测试对于任何应用程序都至关重要。SpringRunner 和 SpringBootTest 类是运行集成测试的基础。 在本教程中，我们将了解 SpringRunner 和 @SpringBootTest 的用法，以及它们之间的区别。 2、SpringRunner SpringRunner 是 SpringJUnit4ClassRunner 类的别名，可用于基于 JUnit4 的测试类。它加载 Spring TestContext，通过 Spring TestContext，Spring Bean 和 Configuration 可与 JUnit 注解一起使用。需要 JUnit 4.12 或更高版本才能使用它。 通过 @RunWith(SpringRunner.class) 注解测试类来使用此功能： @RunWith(SpringRunner.class) public class SampleIntegrationTest { @Test public void test() { // } } 3、SpringBootTest SpringBootTest 是 SpringRunner 的替代品，可与 JUnit5 配合使用。它还用于运行集成测试和加载 Spring TestContext。 它的功能非常丰富，可通过注解参数提供多种配置。它支持各种 Web 环境模式，如 MOCK、RANDOM_PORT、DEFINED_PORT 和 NONE。我们可以通过注解传递 application properties，在测试运行之前将其注入到 Spring Environment 中。 @SpringBootTest( properties = {"user.name=test_user"}, webEnvironment = MOCK) public class SampleIntegrationTest { @Test public void test() { // } } 要运行集成测试，必须在类级别添加注解 @SpringBootTest。 https://springdoc.cn/how-to-build-a-graphql-api-with-spring-boot/ Sat, 14 Oct 2023 17:14:58 +0800 https://springdoc.cn/how-to-build-a-graphql-api-with-spring-boot/ GraphQL 是一种用于 API 的查询语言和运行时，它允许 API 消费者精确获取所需的信息，而不是服务器完全控制响应内容。某些 REST API 实现需要从多个 URL 加载资源的引用，而 GraphQL API 可以在单个响应中跟踪相关对象之间的引用并返回它们。 本教程逐步演示了如何使用 Spring Boot 和 Spring for GraphQL 构建一个 GraphQL API，用于查询 Neo4j 数据库中相关公司、人员和属性的示例数据集。它还演示了如何使用 Next.js 和 MUI Datagrid 构建一个 React 客户端来消费该 API。客户端和服务器都使用 Auth0 进行认证、授权，服务器使用 Okta Spring Boot Starter，客户端使用 Auth0 React SDK。 如果你想跳过所有步骤，直接运行程序，那么你可以以按照 GitHub Repository 中的 README 说明进行操作。 本文所使用的工具、服务如下： Node.js v18.16.1 npm 9.5.1 Java OpenJDK 17 Docker 24.0.2 Auth0 account Auth0 CLI 1.0.0 HTTPie 3.2.2 Next.js 13.4.19 使用 Spring for GraphQL 构建 GraphQL API 资源服务器（Resource Server）是一个 Spring Boot Web 应用，使用 Spring for GraphQL 暴露了一个 GraphQL API。该 API 允许使用 Spring Data Neo4j 查询 Neo4j 数据库，其中包含公司及其相关所有者和属性的信息。数据来自 Neo4j 用例示例。 https://springdoc.cn/guide-to-modulith-with-spring-boot/ Sat, 14 Oct 2023 07:20:40 +0800 https://springdoc.cn/guide-to-modulith-with-spring-boot/ 本文将教你如何使用 Spring Boot 构建 Modulith，并使用 Spring Modulith 项目的特性。Modulith 是一种软件架构模式，假设将你的单体应用程序组织成逻辑模块。这些模块应尽可能独立于彼此。Modulith 平衡了单体架构和基于微服务的架构。它可以成为组织应用程序的目标模型。但你也可以将其视为从单体架构向基于微服务的方法迁移的过渡阶段。Spring Modulith 将帮助我们构建结构良好的 Spring Boot 应用程序，并验证逻辑模块之间的依赖关系。 我们将比较当前的方法和基于微服务的架构。为此，我们将实现与我最近一篇关于 使用 Spring Cloud 和 Spring Boot 3 构建微服务 的文章中所描述的非常相似的功能。 源码 你可以克隆我的 GitHub Repository，然后按照说明操作即可。 在开始之前，我们先来看看下图。它展示了我们示例系统的架构。我们有三个独立的模块，它们相互通信：employee（员工）、department（部门）和 organization（组织）。此外还有 gateway（网关）模块。它负责将内部服务作为 REST 端点暴露在应用之外。我们的模块使用 Spring Modulith 项目提供的支持向 Zipkin 实例发送追踪。 如果你想将其与先前提到的文章中描述的类似微服务架构进行比较，这是该架构的图。 让我们来看看代码的结构。默认情况下，main 的每个直接子包都被视为一个应用模块包。因此有四个应用模块：department、employee、gateway 和 organization。每个模块都包含向其他模块开放的 “provided interfaces”（提供的接口）。我们需要将它们放在应用模块根目录下。其他模块不能访问应用模块子包中的任何类或 bean。我们将在接下来的章节中详细介绍。 src/main/java └── pl └── piomin └── services ├── OrganizationAddEvent.java ├── OrganizationRemoveEvent.java ├── SpringModulith.java ├── department │ ├── DepartmentDTO.java │ ├── DepartmentExternalAPI.java │ ├── DepartmentInternalAPI. https://springdoc.cn/scope-annotation-is-invalidated/ Fri, 13 Oct 2023 07:06:26 +0800 https://springdoc.cn/scope-annotation-is-invalidated/ scope 属性，相信大家都知道，一共有六种： 取值 含义 生效条件 singleton 表示这个 Bean 是单例的，在 Spring 容器中，只会存在一个实例。 prototype 多例模式，每次从 Spring 容器中获取 Bean 的时候，才会创建 Bean 的实例出来。 request 当有一个新的请求到达的时候，会创建一个 Bean 的实例处理。 web 环境下生效 session 当有一个新的会话的时候，会创建一个 Bean 的实例出来。 web 环境下生效 application 这个表示在项目的整个生命周期中，只有一个 Bean。 web 环境下生效 gloablsession 有点类似于 application，但是这个是在 portlet 环境下使用的。 web 环境下生效 这个用法也很简单，通过配置就可以设置一个 Bean 是否为单例模式。 1、问题呈现 今天我要说的不是基础用法，是另外一个问题，假设我现在有如下两个 Bean： @Service public class UserService { @Autowired UserDao userDao; } @Repository public class UserDao { } 在 UserService 中注入 UserDao，由于两者都没有声明 scope，所以默认都是单例的。 现在，如果我给 UserDao 设置 Scope，如下： https://springdoc.cn/using-records-as-projections-in-jpa/ Thu, 12 Oct 2023 19:44:00 +0800 https://springdoc.cn/using-records-as-projections-in-jpa/ Java 16 中引入的 Java Record 允许轻松地定义数据类（Data Class），这非常适合用于 JPA 中的投影查询。 Record 不能作为实体类 Record 只能用于投影查询。像 Hibernate 等流行的 JPA 实现创建代理对象时需要无参构造函数、非 final 字段、setter 方法和非 final 的实体类。而这些特性在 Record 中要么被不鼓励使用，要么被明确禁止使用。 Record 和 JPA 如果你在应用中直接使用 JPA，有几种不同的方法可以将记 Record 整合到 DAO 层中。 CriteriaBuilder Record 可与 CriteriaBuilder 一起使用，如下： public List<AdvocateRecord> findAllWithCriteriaBuilder() { CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaQuery<AdvocateRecord> cq = cb.createQuery(AdvocateRecord.class); Root<AdvocateEntity> root = cq.from(AdvocateEntity.class); cq.select(cb.construct( AdvocateRecord.class, root.get("id"), root.get("fName"), root.get("lName"), root.get("region"), root.get("twitterFollowers"))); TypedQuery<AdvocateRecord> q = em.createQuery(cq); return q.getResultList(); } TypedQuery Record 也可以与 TypedQuery 一起使用，但需要在 JPQL 查询中提供完整类路径的构造函数。 https://springdoc.cn/spring-security-oauth2-tutorial-service-to-service-communication-using-client-credentials-flow/ Thu, 12 Oct 2023 08:53:09 +0800 https://springdoc.cn/spring-security-oauth2-tutorial-service-to-service-communication-using-client-credentials-flow/ 在本文中，我们将学习如何使用 “客户端凭证模式”（Client Credentials Flow）实现服务间的通信。我们将创建 archival-service，在其中通过定时任务使用 “客户端凭证模式” 来调用 messages-service API 以归档消息。 我们还会在 archival-service 中实现 POST /api/messages/archive API 端点，只有拥有 ROLE_ADMIN 角色的用户才能调用。 有鉴于此，archival-service 既是资源服务器（Resource Server），也是客户端。 资源服务器 - 暴露 POST /api/messages/archive API 端点，该端点将由 messages-webapp 调用。 客户端 - 调用 messages-service API 来归档消息。 你可以从 Github 仓库 获取到当前项目的完整源码。 在 Keycloak 中启用客户端凭证模式，创建 archival-service 客户端 创建一个名为 archival-service 的新客户端： General Settings： Client type：OpenID Connect Client ID：archival-service Capability config： Client authentication：On Authorization：Off Authentication flow：选中 Service accounts roles，取消选中其余复选框 Login settings: Root URL: http://localhost:8282 Home URL: http://localhost:8282 使用上述配置创建客户端后，你将进入新创建的客户端 “Settings” 页面。 https://springdoc.cn/spring-security-oauth2-tutorial-integrating-client-and-resource-server/ Thu, 12 Oct 2023 08:10:52 +0800 https://springdoc.cn/spring-security-oauth2-tutorial-integrating-client-and-resource-server/ 在前面的文章中，我们创建了 messages-webapp 和 messages-service，并使用 Postman 调用了 API 端点。在本文中，我们将学习如何从客户端应用 messages-webapp 调用受保护的 messages-service API 端点。 你可以从 Github 仓库 获取到完整的源码。 展示消息列表 由于 messages-service 中的 GET /api/messages API 端点是可公开访问的，因此我们可以从 messages-webapp 调用它，而无需任何身份认证。 RestTemplate 和 RestClient 我们使用传统的 RestTemplate 来调用 messages-service 中的 API 端点。但在 Spring Boot 3.2.0 后，建议改用 RestClient。 在 messages-webapp 中，创建 AppConfig 类，如下： package com.sivalabs.messages.config; import org.springframework.boot.web.client.RestTemplateBuilder; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.client.RestTemplate; @Configuration public class AppConfig { @Bean public RestTemplate restTemplate(RestTemplateBuilder builder) { return builder.build(); } } 我们注册了一个 RestTemplate Bean，以便将其注入到其他组件中。 https://springdoc.cn/spring-security-oauth2-tutorial-securing-resource-server/ Wed, 11 Oct 2023 16:18:40 +0800 https://springdoc.cn/spring-security-oauth2-tutorial-securing-resource-server/ 在 上一篇文章 中，我们创建了 messages-webapp，并使用 “授权码模式” 通过 Spring Security OAuth 2.0 对其进行了访问控制。在本文中，我们将创建 messages-service（Spring Boot 资源服务器），并使用 Spring Security OAuth 2.0 进行访问控制。 你可以在 Github 仓库 找到该项目完整的源码。 创建 messages-service 点击此 链接 可使用 Spring Initializr 生成 messages-service。我们选择了 Web、Validation、Security 和 OAuth2 Resource Server Starter。应用生成后，在 IDE 打开它。 配置 OAuth 2.0 资源服务器属性 messages-service 是 bearer-only 类型的资源服务器。这意味着如果有人使用有效的 access_token 作为 Authorization 头发送请求到受保护的 API 端点，该服务将返回响应。否则，它将只会返回 401 或 403 的 HTTP 状态码，而不会启动 OAuth 2.0 的授权流程。 bearer-only 类型的资源服务器无需向授权服务器（Keycloak）注册。我们只需在 application.properties 文件中配置 issuer-uri 如下： spring.application.name=messages-service server. https://springdoc.cn/spring-security-oauth2-tutorial-securing-springmvc-client-application/ Wed, 11 Oct 2023 14:50:46 +0800 https://springdoc.cn/spring-security-oauth2-tutorial-securing-springmvc-client-application/ 在本文中，我们将创建一个名为 messages-webapp 的 Spring MVC + Thymeleaf Web 应用，并使用 Keycloak 进行访问控制，使用 Spring Security OAuth 2.0 进行认证。 你可以在 Github 上找到该项目的完整源码。 使用 Docker Compose 安装 Keycloak 在上一篇文章中，我们已经了解了如何使用 Docker Compose 安装 Keycloak。 创建 docker-compose.yml 文件，内容如下： version: '3.8' name: spring-security-oauth2-microservices-demo services: keycloak: image: quay.io/keycloak/keycloak:22.0.3 command: ['start-dev'] container_name: keycloak hostname: keycloak environment: - KEYCLOAK_ADMIN=admin - KEYCLOAK_ADMIN_PASSWORD=admin1234 ports: - "9191:8080" 运行以下命令启动 Keycloak 实例： $ docker compose up -d 现在，你可以访问 Keycloak 管理控制台 http://localhost:9191/，并使用 admin/admin1234 登录。 创建 Keycloak Realm、客户端和用户 在前面的文章中，我们已经学习了如何创建 Realm、客户端和用户。请按照 前文 中提到的步骤创建新的 Realm、客户端和用户，只需更改 “Valid redirect URIs”。 https://springdoc.cn/spring-security-oauth2-tutorial-microservices-project-setup/ Wed, 11 Oct 2023 10:10:32 +0800 https://springdoc.cn/spring-security-oauth2-tutorial-microservices-project-setup/ 在之前的文章中，我们学习了使用 Web 浏览器、cURL 和 Postman 进行各种 OAuth 2.0 / OpenID Connect Flow。现在是时候学以致用了。 在使用像 Spring Security 这样的安全框架实现基于 OAuth 2.0 / OpenID Connect 的 Security 时，许多活动都是由框架在幕后执行的。了解框架内部发生的情况非常重要，这样我们才能有效地使用框架。 在本文中，我将简要介绍我们将在 Spring Security OAuth 2 教程系列中使用的基于微服务的示例项目。 示例 Spring Boot 微服务项目 我们将构建一个包含以下组件的微服务示例项目： Authorization Server - 这是 OAuth 2.0 授权服务器，将向客户端发放访问令牌。我们将使用 Keycloak 作为授权服务器。 messages-webapp - 终端用户将使用的基于 Spring MVC 的客户端应用。 messages-service - Spring Boot REST API（资源服务器）用于管理用户数据（消息），并将由 messages-webapp 应用使用。 archival-service - Spring Boot 应用可使用定时任务定期处理消息存档。它还提供了一个 API 端点来触发存档过程。该服务将同时扮演资源服务器和客户端的角色。 让我们来了解一下这些组件各自提供的功能。 messages-webapp（客户端） 这是一个使用 Spring MVC 和 Thymeleaf 渲染用户界面的 Spring Boot Web 应用。该应用将受到授权服务器（Keycloak）的保护，并将使用 “授权码模式” 来认证用户身份并获取访问令牌。 https://springdoc.cn/spring-security-oauth2-tutorial-implicit-and-resource-owner-password-credentials-flow/ Wed, 11 Oct 2023 09:28:20 +0800 https://springdoc.cn/spring-security-oauth2-tutorial-implicit-and-resource-owner-password-credentials-flow/ 在 “Spring Security OAuth 2 教程 - 4：PKCE 授权码模式” 中，我们学习了如何通过 PKCE 授权码模式获取访问令牌（access_token）。在本文中，我们将了解如何使用隐式模式（Implicit Flow）和资源所有者密码凭证模式（Resource Owner Password Credentials Flow）。 注意 隐式模式和资源所有者密码凭证模式已被淘汰，没有特别理由不应该再使用。 隐式模式 隐式模式（Implicit Flow）是授权码模式（Authorization Code Flow）的一种简化版本，你可以直接通过授权端点（authorization_endpoint）获取访问令牌（access_token）。 如果你一直关注本系列，就会知道如何创建一个启用了特定 “Authentication flow” 的客户端。这里，我们直接为 messages-webapp 客户端启用隐式模式。 要了解如何创建新客户端，请参阅 创建客户端。 在浏览器窗口中打开以下 URL： http://localhost:9191/realms/sivalabs/protocol/openid-connect/auth? response_type=id_token%20token &client_id=messages-webapp &redirect_uri=http://localhost:8080/callback &scope=openid%20profile &state=randomstring &nonce=another_randomstring 然后，你将被重定向到 Keycloak 的登录页面。 使用凭证 siva/siva1234 登录。 然后，你将被重定向到包含 access_token 和 id_token 查询参数的重定向 URI。 http://localhost:8080/callback# state=randomstring &session_state=51692fdb-8b72-45b7-a341-fa73e97b5139 &id_token=eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJMeVVPTDg4LVBGM3BYQzFpN3BIeGdFZTJwaWZJY3RyTXJiNklHOElmRTlVIn0.eyJleHAiOjE2OTU2MTUzOTQsImlhdCI6MTY5NTYxNDQ5NCwiYXV0aF90aW1lIjoxNjk1NjE0NDk0LCJqdGkiOiI2MjFmNTJmMC0wMDBmLTQ1ZmUtYWYzOC1iY2YzZWM2ZDk1MTEiLCJpc3MiOiJodHRwOi8vbG9jYWxob3N0OjkxOTEvcmVhbG1zL3NpdmFsYWJzIiwiYXVkIjoibWVzc2FnZXMtd2ViYXBwIiwic3ViIjoiY2ExYTJmMzQtMTYxNC00NWRkLTg2YzEtNWVhZmZmMDg1ZDhhIiwidHlwIjoiSUQiLCJhenAiOiJtZXNzYWdlcy13ZWJhcHAiLCJub25jZSI6ImFub3RoZXJfcmFuZG9tc3RyaW5nIiwic2Vzc2lvbl9zdGF0ZSI6IjUxNjkyZmRiLThiNzItNDViNy1hMzQxLWZhNzNlOTdiNTEzOSIsImF0X2hhc2giOiJiamR6MC1NeWltQ0xrSzdqaWRRbHp3IiwiYWNyIjoiMSIsInNfaGFzaCI6IlJtVE5Ld0lYaTNXRFhzRFlObTQtUHciLCJzaWQiOiI1MTY5MmZkYi04YjcyLTQ1YjctYTM0MS1mYTczZTk3YjUxMzkiLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZSwibmFtZSI6IlNpdmEgS2F0YW1yZWRkeSIsInByZWZlcnJlZF91c2VybmFtZSI6InNpdmEiLCJnaXZlbl9uYW1lIjoiU2l2YSIsImZhbWlseV9uYW1lIjoiS2F0YW1yZWRkeSIsImVtYWlsIjoic2l2YUBnbWFpbC5jb20ifQ.TIcmVBti96HuZvrYe_14mVJlfopXI2PhdMdWBtPPASpJc-DKrL9argy08sYZKqJTTcmWwnIwKK2o1vddVxA4zUP2tnqqg6ymz1trN3J8r4h-WSvIp907vnS0R7iHei56L6MQX2DZLJ8pOdSmti8wg_9fu4gQJBE2sHRTlrlOP39dh8yohMGidM-Z5iFbLCIzOQXA6B6ewMZll5iwL3ssJ716Ve9cO4qHGCneRGpb3mO7jclY87YSGM-wqr6ur00ylQ_BCGyCdl-f-xskSeDX09iQKFSTX_acMxB7FNi21BL7dMx8_22XPFOwNkX8ha8Vb7eTRMYEMyB776i33FLu0A &access_token=eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJMeVVPTDg4LVBGM3BYQzFpN3BIeGdFZTJwaWZJY3RyTXJiNklHOElmRTlVIn0.eyJleHAiOjE2OTU2MTUzOTQsImlhdCI6MTY5NTYxNDQ5NCwiYXV0aF90aW1lIjoxNjk1NjE0NDk0LCJqdGkiOiI1N2NiYmRkMC0wNGFmLTRlMDctYWZlNC02ZmQ5MmY0YjA2MzAiLCJpc3MiOiJodHRwOi8vbG9jYWxob3N0OjkxOTEvcmVhbG1zL3NpdmFsYWJzIiwiYXVkIjoiYWNjb3VudCIsInN1YiI6ImNhMWEyZjM0LTE2MTQtNDVkZC04NmMxLTVlYWZmZjA4NWQ4YSIsInR5cCI6IkJlYXJlciIsImF6cCI6Im1lc3NhZ2VzLXdlYmFwcCIsIm5vbmNlIjoiYW5vdGhlcl9yYW5kb21zdHJpbmciLCJzZXNzaW9uX3N0YXRlIjoiNTE2OTJmZGItOGI3Mi00NWI3LWEzNDEtZmE3M2U5N2I1MTM5IiwiYWNyIjoiMSIsImFsbG93ZWQtb3JpZ2lucyI6WyJodHRwOi8vbG9jYWxob3N0OjgwODAiXSwicmVhbG1fYWNjZXNzIjp7InJvbGVzIjpbImRlZmF1bHQtcm9sZXMtc2l2YWxhYnMiLCJvZmZsaW5lX2FjY2VzcyIsInVtYV9hdXRob3JpemF0aW9uIl19LCJyZXNvdXJjZV9hY2Nlc3MiOnsiYWNjb3VudCI6eyJyb2xlcyI6WyJtYW5hZ2UtYWNjb3VudCIsIm1hbmFnZS1hY2NvdW50LWxpbmtzIiwidmlldy1wcm9maWxlIl19fSwic2NvcGUiOiJvcGVuaWQgZW1haWwgcHJvZmlsZSIsInNpZCI6IjUxNjkyZmRiLThiNzItNDViNy1hMzQxLWZhNzNlOTdiNTEzOSIsImVtYWlsX3ZlcmlmaWVkIjp0cnVlLCJuYW1lIjoiU2l2YSBLYXRhbXJlZGR5IiwicHJlZmVycmVkX3VzZXJuYW1lIjoic2l2YSIsImdpdmVuX25hbWUiOiJTaXZhIiwiZmFtaWx5X25hbWUiOiJLYXRhbXJlZGR5IiwiZW1haWwiOiJzaXZhQGdtYWlsLmNvbSJ9.XsYc69HnM9VaJZFF568nRiZhh8RYEw6Hq2WGnJ4jr3tmZvgMF0QK2RtlBT9BuX4A11XHjyNZqGYNf55x0k4bPXjhPzWI-lC0shhsKrXGYrnhVcComXxMbO_38ypRY_EMeBWRTXu0bvcKInYMjVoItfoLheH-kbcziK6O16yFGftOG-YYw0uVzs_DrOkjQjs1BS2L56yXcRgN72EBXMT-Cv6OLMTSj6WXjfg1nmRl0NRJdeZv0iafSolmqSpJeqXwPzM2hgZ2hPzaq90qipndQrZ05xesMtzXMNlev0ozYPN7xKSa7arHMYky8y4OMpCQDJzkSwekjUEQUSU9Sqg_VA &token_type=Bearer &expires_in=900 如你所见，access_token 和 id_token 是通过浏览器 URL 前端返回的，这并不安全。 资源所有者密码凭证模式 在 “资源所有者密码凭证模式” 中，我们将使用资源所有者（终端用户）凭证获取 access_token 和 id_token。 https://springdoc.cn/spring-security-oauth2-tutorial-authorization-code-flow-with-pkce/ Wed, 11 Oct 2023 08:57:21 +0800 https://springdoc.cn/spring-security-oauth2-tutorial-authorization-code-flow-with-pkce/ 在 “Spring Security OAuth 2 教程 - 3：客户端凭证模式” 中，我们学习了如何通过客户端凭证模式获取访问令牌（access_token）。在本文中，我们将了解如何使用 PKCE 授权码模式。 PKCE 授权码模式 PKCE 授权码模式是 OpenId Connect Flow，主要用于保护本地、移动应用和单页应用 (SPA) 的安全。PKCE 是代码交换证明密钥（Proof Key for Code Exchange）的首字母缩写。 注意 PKCE 授权码模式也可用于保护服务器上运行的 Web 应用的安全。在这种情况下，PKCE 起到了额外保护层的作用。 创建 “public” 客户端 创建一个名为 messages-spa 的新客户端。 General Settings： Client type：OpenID Connect Client ID：messages-spa Capability config： Client authentication：Off Authorization：Off Authentication flow：选中 Standard flow，取消选中其余复选框 Login settings： Root URL：http://localhost:3000 Home URL：http://localhost:3000 Valid redirect URIs：http://localhost:3000/callback Valid post logout redirect URIs：http://localhost:3000 Web origins：http://localhost:3000 使用上述配置创建客户端后，你将进入新创建的客户端 “Settings” 页面。单击 “Advanced” 选项卡，转到 “Advanced Settings” 部分，将 “Proof Key for Code Exchange Code Challenge Method” 值更新为 S256。 https://springdoc.cn/spring-security-oauth2-tutorial-client-credentials-flow/ Wed, 11 Oct 2023 08:31:31 +0800 https://springdoc.cn/spring-security-oauth2-tutorial-client-credentials-flow/ 在第二章 “Spring Security OAuth 2 教程 - 2：授权码模式” 中，我们学习了如何通过授权码模式（Authorization Code Flow）对用户进行身份认证。在本文中，我们将了解如何使用客户端凭证模式（Client Credentials Flow），它通常用于服务之间的通信，而无需任何用户（资源所有者）上下文。 客户端凭证模式 有时资源服务器需要在没有任何用户上下文的情况下与另一个资源服务器进行交互。例如，资源服务器 A 可能会运行一个定时任务，该任务将调用资源服务器 B 上的受保护的 REST API 端点。在这些情况下，我们可以通过 “客户端凭证模式” 从授权服务器（Authorization Server）获取访问令牌（access_token）。 创建客户端并启用客户端凭证模式 客户端使用 “客户端凭证模式”，需要启用 “客户端凭证授权支持”。在 Keycloak 中，可以通过启用 Service accounts roles 认证模式来启用 “客户端凭证授权”。 OAuth2 客户端多重授权 OAuth 2.0 客户端可启用多种授权方式，如授权码、客户端凭证、隐式等。 创建一个名为 archival-service 的新客户端。 General Settings： Client type：OpenID Connect Client ID：archival-service Capability config： Client authentication：On Authorization：Off Authentication flow：选中 Service accounts roles，取消选中其余复选框 Login settings： Root URL：http://localhost:8282 Home URL：http://localhost:8282 使用上述配置创建客户端后，你将进入新创建的客户端 “Settings” 页面。单击 “Credentials” 选项卡并复制 “Client secret”值。 https://springdoc.cn/spring-security-oauth2-tutorial-authorization-code-flow/ Tue, 10 Oct 2023 20:26:37 +0800 https://springdoc.cn/spring-security-oauth2-tutorial-authorization-code-flow/ 在 “Spring Security OAuth 2 教程 - 1：熟悉 OAuth 2 概念” 中，我们学习了如何设置 Keycloak、创建 Realm、启用 Standard flow 的客户端和用户。在本文中，我们将了解如何通过 “授权码模式”（Authorization Code Flow）对用户进行身份认证。 首先，让我们澄清一下 “授权码授权方式”（Authorization Code Grant Type）与 “授权码模式”（Authorization Code Flow）之间的混淆。 正如我之前提到的，OAuth 2.0 规范仅关注授权（Authorization），而 OpenID Connect 规范是在 OAuth 2.0 之上添加的一层，用于处理身份认证（Authentication）。 “授权码授权方式”（Authorization Code Grant Type）是 OAuth 2.0 的术语，而 “授权码模式”（Authorization Code Flow）是 OpenID Connect 的术语。它们的工作方式相同，区别在于 scope。通过本文后面的示例，我们将更清楚地了解 “授权码模式” 的差异。 快速回顾一下，我们在上一教程中，创建的客户端（Client）和用户（User）的详细信息如下。 Client id：messages-webapp Client secret：qVcg0foCUNyYbgF0Sg52zeIhLYyOwXpQ Username：siva Password：siva1234 OAuth 2.0 架构 以下是基于 OAuth 2.0 的系统的架构图： 资源所有者（Resource Owner），也就是终端用户，希望使用客户端（Client）应用访问其存储在资源服务器（Resource Server）上的数据。 资源服务器（Resource Server）数据受保护，需要访问令牌（access_token）才能访问数据。 客户端（Client）应用将管理用户、签发访问令牌（access_token）和认证用户的责任转交给了授权服务器（Authorization Server）。 当你（Resource Owner）试图在客户端（Client）应用上访问受保护的资源时，你将被重定向到授权服务器（Authorization Server），在那里你需要通过提供用户凭证来认证自己的身份。 如果认证成功，授权服务器（Authorization Server）就会向客户端（Client）签发访问令牌（access_token）。 然后，客户端（Client）就可以使用访问令牌（access_token）访问受保护的用户的数据了。 这是终端用户如何使用基于 OAuth 2. https://springdoc.cn/spring-security-oauth2-tutorial-introduction/ Tue, 10 Oct 2023 17:37:55 +0800 https://springdoc.cn/spring-security-oauth2-tutorial-introduction/ 安全是一个需要深入理解的复杂主题。此外，使用 OAuth 2.0 和 OpenID Connect 规范为基于微服务的复杂系统实现认证和授权更加困难。像 Spring Security 这样的框架和库有助于降低复杂性，但要正确实现 Security 仍然需要经历陡峭的学习曲线。 在本 Spring Security OAuth2 系列教程中，我将与大家分享如何使用 Spring Security OAuth2 为基于微服务的应用实现认证和授权。 有许多身份提供商（Identity Provider）解决方案，如 Keycloak、Okta、Auth0 等。在本系列中，我们将使用开源身份和访问管理解决方案 Keycloak。 我不是安全、OAuth2 和 Keycloak 方面的专家。我只是根据自己对这些概念的理解与大家分享我的学习心得。如果你认为其中有任何概念或解释不正确，请指正。 我们不会直接进入 Spring Security OAuth2 的实现，而是先从概念开始学习，循序渐进。 了解 OAuth 2.0 和 OpenID Connect 的基础知识 学习 OAuth 2.0 和 OpenID Connect 的第一步是了解一些核心概念，如 OAuth2 中的各种角色（Role）是什么、各种授权方式（Grant Type）是什么以及何时使用哪种方式。 简而言之，在 OAuth2 系统中，有各种不同的组件扮演着不同的角色，也有不同的方法来验证用户身份。 OAuth2.0 角色（Role） 资源所有者（Resource Owner）： 资源所有者通常是终端终用户，他授权应用（客户端）访问他/她的账户。 资源服务器（Resource Server）： 托管受保护资源的服务器。这是你要访问的 API。 客户端（Client）： 代表资源所有者请求访问受保护资源的应用（资源所有者正在使用的应用）。 授权服务器（Authorization Server）： 对资源所有者进行身份验证并在成功授权后发放访问令牌（Access Token）的服务器。 OAuth2. https://springdoc.cn/spring-cloud-2023-support-for-synchronization-gateways/ Tue, 10 Oct 2023 15:10:25 +0800 https://springdoc.cn/spring-cloud-2023-support-for-synchronization-gateways/ 网关不支持传统 Servlet 容器 Spring Cloud Gateway 需要运行在提供的 Netty 运行时。它不能在传统的 Servlet 容器中工作，也不能在构建为 WAR 时工作。WebFlux 使用了异步非阻塞的编程模型，相较于传统的 MVC Servlet 需要理解和适应新的编程范式和响应式编程概念，因此学习曲线可能较陡峭。 如果在 spring-cloud-gateway 引入了 tomcat 等传统容器会抛出如下异常： 14 Caused by: org.springframework.boot.web.server.WebServerException: Unable to start embedded Tomcat 15 at org.springframework.boot.web.embedded.tomcat.TomcatWebServer.initialize(TomcatWebServer.java:124) ~[spring-boot-2.1.6.RELEASE.jar:2.1.6.RELEASE] 16 at org.springframework.boot.web.embedded.tomcat.TomcatWebServer.<init>(TomcatWebServer.java:86) ~[spring-boot-2.1.6.RELEASE.jar:2.1.6.RELEASE] 17 at org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory.getTomcatWebServer(TomcatServletWebServerFactory.java:414) ~[spring-boot-2.1.6.RELEASE.jar:2.1.6.RELEASE] 18 at org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory.getWebServer(TomcatServletWebServerFactory.java:178) ~[spring-boot-2.1.6.RELEASE.jar:2.1.6.RELEASE] 19 at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.createWebServer(ServletWebServerApplicationContext.java:179) ~[spring-boot-2.1.6.RELEASE.jar:2.1.6.RELEASE] 20 at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.onRefresh(ServletWebServerApplicationContext.java:152) ~[spring-boot-2.1.6.RELEASE.jar:2.1.6.RELEASE] 21 ... 8 common frames omitted MVC Servlet 支持 在 SpringCloud 2023 版本（Spring Cloud Gateway 4. https://springdoc.cn/spring-docker-liberica/ Tue, 10 Oct 2023 13:43:07 +0800 https://springdoc.cn/spring-docker-liberica/ 1、简介 在本教程中，我们将了解如何把使用 Spring Boot 创建的 Java 应用作为 Docker 容器运行，具体来说，我们将在 Alpaquita Linux 上使用 Liberica JDK 来创建运行我们应用的 Docker 镜像。 Liberica JDK 和 Alpaquita Linux 是 BellSoft 产品的一部分。BellSoft 的愿景是使 Java 成为云原生应用程序的首选语言。 2、简单的 Spring Boot 应用 先用 Java 创建一个简单的应用，然后将其容器化。通过 Spring Boot，我们只需进行最少的配置，就能轻松创建基于 Spring 的独立生产级应用。 初始化 Spring Boot 应用的最简单方法是使用 Spring Boot CLI。通过它，可以在命令行中使用 start.springboot.io 创建一个新项目： $ spring init --build=gradle --dependencies=web spring-bellsoft 如上，添加了 web 依赖，以构建 RESTful API，并将 Apache Tomcat 作为默认的嵌入式容器。选择 Gradle 作为构建工具，默认的语言是 Java。 然后，可以将生成的项目导入 IDE（如 IntelliJ Idea），开始开发应用。 添加一个简单的 REST API，接收一个 Integer 参数，并返回等于或小于该数字的斐波纳契数列： https://springdoc.cn/spring-deprecated-websecurityconfigureradapter/ Tue, 03 Oct 2023 14:47:09 +0800 https://springdoc.cn/spring-deprecated-websecurityconfigureradapter/ 1、概览 Spring Security 允许通过继承 WebSecurityConfigurerAdapter 类来自定义 HTTP Security，例如端点授权或 Authentication Manager 配置。然而，在最近的版本中，Spring 已经弃用了这种方法，并推荐使用基于组件的 security 配置。 本文将会带你学习如何在 Spring Boot 应用中代替这些已废弃的方法。 2、Spring Security 不使用 WebSecurityConfigurerAdapter 常见的 Spring HTTP Security 配置类都会继承一个 WebSecurityConfigureAdapter 类。 从 5.7.0-M2 起，WebSecurityConfigureAdapter 被废弃了，不推荐使用。 创建一个基于内存验证的 Spring Boot 应用示例来演示如何进行新的配置。 首先，定义配置类： @EnableWebSecurity @EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true, jsr250Enabled = true) public class SecurityConfig { // config } 添加 Method Security 注解，根据不同角色进行处理。 2.1、配置 Authentication 使用 WebSecurityConfigureAdapter 时，使用 AuthenticationManagerBuilder 来设置 Authentication Context。 现在，可以定义一个 UserDetailsManager 或 UserDetailsService 来避免组件过时的问题： https://springdoc.cn/spring-boot-properties-env-variables/ Tue, 03 Oct 2023 11:05:22 +0800 https://springdoc.cn/spring-boot-properties-env-variables/ 1、概览 本文介绍了如何在 Spring Boot 的 application.properties 和 application.yml 中使用环境变量，以及如何在代码中使用这些属性。 2、在 application.properties 文件中使用环境变量 定义一个名为 JAVA_HOME 的全局环境变量，其值为 C:\Program Files\Java\jdk-11.0.14。 要在 Spring Boot 的 application.properties 中使用该变量，需要用大括号将其包裹起来： java.home=${JAVA_HOME} 也可以以同样的方式使用系统属性（System Properties）。例如，在 Windows 系统中，默认情况下会定义操作系统属性： environment.name=${OS} 还可以组合多个变量值。定义另一个环境变量 HELLO_BAELDUNG，其值为 Hello Baeldung。现在可以将两个变量连接起来： baeldung.presentation=${HELLO_BAELDUNG}. Java is installed in the folder: ${JAVA_HOME} baeldung.presentation 属性值现在为：Hello Baeldung. Java is installed in the folder: C:\Program Files\Java\jdk-11.0.14. 3、在代码中使用特定环境属性 启动 Spring Context 后，就可以在代码中注入属性值。 3.1、使用 @Value 注入属性值 可以使用 @Value 注解在 setter 方法、构造器和字段上进行注入： @Value("${baeldung.presentation}") private String baeldungPresentation; 3.2、从 Spring Environment 获取值 还可以通过 Spring 的 Environment 获取属性值。 https://springdoc.cn/spring-boot-3-spring-6-new/ Mon, 02 Oct 2023 10:07:20 +0800 https://springdoc.cn/spring-boot-3-spring-6-new/ 1、概览 本文简单地介绍了 Spring Boot 3 和 Spring Framework 6.0 中的新特性。 2、Java 17 之前已经支持Java 17，现在这个 LTS 版本成为基线版本。 由于 Java 本身不是本文的主题，这里只会列举对 Spring Boot 开发人员最重要的新特性。 2.1、Record Java Record（JEP 395），是一种快速创建数据类（Data Class）方式，即那些目的仅仅是包含数据并在模块之间传递数据的类，也被称为 POJO（Plain Old Java Objects，简单Java对象）和 DTO（Data Transfer Objects，数据传输对象）。 使用 Record 可以轻松创建不可变的 DTO： public record Person (String name, String address) {} 目前，在将它们与 Bean Validation 结合使用时，需要小心，因为构造函数参数不支持验证约束，例如在 Controller 方法中的 JSON 对象。 2.2、字符块 通过 JEP 378，现在就可以创建多行文本块，而无需在换行时连接字符串： String textBlock = """ Hello, this is a multi-line text block. """; 2. https://springdoc.cn/spring-boot-redisson/ Wed, 27 Sep 2023 08:55:55 +0800 https://springdoc.cn/spring-boot-redisson/ Redisson 是一个功能十分强大的 Redis Java 客户端，它提供了丰富的功能和API，支持同步和异步操作，以及 RxJava 和响应式编程模型。Redisson 提供了50多个基于 Redis 的 Java 对象和服务，包括 分布式锁、原子计数器、分布式集合（Set、Map、List、Queue） 等高级功能。它还还支持本地缓存和 RPC 调用等功能，是开发分布式应用和使用 Redis 的理想选择。 总之，Redisson 所提供的功能已经远远超出了一个 Redis 客户端的范畴，Redis 官方也 推荐使用它 作为 Java 的 Redis 客户端。 之前我们介绍过 如何在 Spring Boot 中整合、使用 Redis。我们用到了 Spring Data Redis 组件，这是由 Spring 提供的抽象，可以使用 Jedis、Lettuce 等客户端作为实现。 Redisson 官方提供了一个 redisson-spring-boot-starter 组件，它正是 Spring Data Redis 抽象的实现，也就是说，我们可以直接使用 redisson-spring-boot-starter 无缝替换 spring-boot-starter-data-redis。 本文将会带你了解如何在 Spring Boot 中通过 redisson-spring-boot-starter 整合、使用 Redisson。 整合 Redisson 添加依赖 添加 redisson-spring-boot-starter 依赖即可。 <!-- https://mvnrepository.com/artifact/org.redisson/redisson-spring-boot-starter --> <dependency> <groupId>org. https://springdoc.cn/spring-openfeign-propagate-exception/ Wed, 27 Sep 2023 08:55:55 +0800 https://springdoc.cn/spring-openfeign-propagate-exception/ 1、概览 微服务间的 HTTP API 调用可能会出现异常。在 Spring Boot 中使用 OpenFeign 时，默认会把下游服务的 “Not Found” 等异常全部当做 “Internal Server Error” 响应给客户端。这并不是异常的最佳处理方式，幸而，Spring 和 OpenFeign 都提供了一些机制，允许我们自定义异常处理。 本文将带你了解，Spring Boot 和 OpenFeign 默认的异常传播、处理机制，以及如何实现自定义的异常处理。 2、默认的异常传播策略 2.1、Feign 中默认的异常传播 Feign 使用 ErrorDecoder.Default 内部实现类进行异常处理。每当 Feign 收到任何非 2xx 状态码时，都会将其传递给 ErrorDecoder 的 decode 方法。 如果 HTTP 响应有 Retry-After 头信息，decode 方法就会返回 RetryableException，否则就会返回 FeignException。 重试时，如果请求在默认重试次数之后仍然失败，则会返回 FeignException。 decode 方法将 HTTP 方法 key 和响应存储在 FeignException 中。 2.2、Spring Rest Controller 中的默认异常传播 只要 RestController 收到任何未处理的异常，它就会向客户端返回 500 Internal Server Error（内部服务器错误）响应。 该异常响应包含时间戳、HTTP 状态码、异常信息和路径等信息： https://springdoc.cn/build-spring-initializr-service/ Tue, 26 Sep 2023 10:43:42 +0800 https://springdoc.cn/build-spring-initializr-service/ Spring Initializr 是 Spring 官方提供的一个用于快速创建和初始化 Spring 项目的在线工具。它可以让开发人员选择所需的 Spring 模块、版本、语言（Java、Kotlin 或 Groovy）和构建工具（Maven 或 Gradle），并生成一个基本的项目结构。现在大多数 IDE 都对 Spring Initializr 提供了支持！ 官方的 Spring Initializr 服务（start.spring.io）部署在海外，在国内访问经常出现各种连网络接失败的问题。好在 Spring Initializr 是一个开源的项目，我们可以用它来构建自己的 Spring Initializr 服务。 Spring Initializr Github 仓库：https://github.com/spring-io/start.spring.io 构建 Spring Initializr 服务 Clone 项目 需要先在机器上安装 git 软件。 git clone https://github.com/spring-io/start.spring.io.git 该仓库下有三个工程，我们只关心其中2个： start-client 前端工程，使用 React 开发。 start-site 后端工程，是一个 Spring Boot 应用。 执行构建 项目使用 maven 构建，且提供了 mvnw（Maven Wrapper） 脚本，它是一个用于管理和运行 Maven 项目的工具。它的作用是在没有全局安装 Maven 的情况下，通过自动下载和配置特定版本的 Maven 来确保项目的构建和运行环境一致性。也就是说 不需要在本地安装 Maven，通过此脚本即可完成构建。 进入项目根目录，执行如下命令进行自动构建： https://springdoc.cn/swagger-operation-vs-apiresponse/ Mon, 25 Sep 2023 15:59:34 +0800 https://springdoc.cn/swagger-operation-vs-apiresponse/ 1、概览 本文将带你了解 Swagger 中 @Operation 和 @ApiResponse 注解的主要区别和应用场景。 2、用 Swagger 生成文档 Swagger 是一套围绕 OpenAPI 规范构建的开源工具，用于描述整个 API，如暴露的端点、操作、参数、验证方法等。 Swagger 提供了 @Operation 和 @ApiResponse 注解，用于描述 REST API，以及 REST API 的响应。 定义一个示例 Controller： @RestController @RequestMapping("/customers") class CustomerController { private final CustomerService customerService; public CustomerController(CustomerService customerService) { this.customerService = customerService; } @GetMapping("/{id}") public ResponseEntity<CustomerResponse> getCustomer(@PathVariable("id") Long id) { return ResponseEntity.ok(customerService.getById(id)); } } 3、@Operation @Operation 注解用于描述单个操作。 @Operation(summary = "Gets customer by ID", description= "Customer must exist") @GetMapping("/{id}") public ResponseEntity<CustomerResponse> getCustomer(@PathVariable("id") Long id) { return ResponseEntity. https://springdoc.cn/spring-security-permitall-vs-anonymous/ Mon, 25 Sep 2023 12:49:38 +0800 https://springdoc.cn/spring-security-permitall-vs-anonymous/ 1、概览 Web 应用中，有些资源只能被已登录（认证）的的用户访问。有些资源，可以被匿名用户访问。而有些资源，甚至只能被匿名用户访问，已登录的用户不能访问。 本文将带你了解 Spring Security 中 HttpSecurity 的 permitAll() 和 anonymous() 方法之间的区别以及如何通过这两个方法实现上述的权限设计。 2、权限设计 假如，我们有一个电商网站，权限设计如下： 匿名用户和已登录的用户均可查看网站上的商品。 需要审计匿名用户和已登录用户请求。 匿名用户可以访问用户注册页面，已经登录的用户则不能访问。 只有已登录的用户才能查看其购物车。 3、Controller 和 WebSecurity 配置 定义 Controller： @RestController public class EcommerceController { @GetMapping("/private/showCart") public @ResponseBody String showCart() { return "Show Cart"; } @GetMapping("/public/showProducts") public @ResponseBody String listProducts() { return "List Products"; } @GetMapping("/public/registerUser") public @ResponseBody String registerUser() { return "Register User"; } } 接下来在 EcommerceWebSecruityConfig 类中实现上述权限设计： @Configuration @EnableWebSecurity public class EcommerceWebSecurityConfig { @Bean public InMemoryUserDetailsManager userDetailsService(PasswordEncoder passwordEncoder) { UserDetails user = User. https://springdoc.cn/spring-boot-data-redis/ Mon, 25 Sep 2023 09:20:41 +0800 https://springdoc.cn/spring-boot-data-redis/ Redis 是一款开源的，使用 C 开发的高性能内存 Key/Value 数据库，支持 String、Set、Hash、List、Stream 等等数据类型。它被广泛用于缓存、消息队列、实时分析、计数器和排行榜等场景。基本上是当代应用中必不可少的软件！ Spring Boot 对 Redis 提供了开箱即用的组件：spring-boot-starter-data-redis。通过这个 starter，我们只需要几行简单的配置就可以快速地在 Spring Boot 中整合、使用 Redis。 Spring Boot 整合 Redis Maven 依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> </dependency> 除了 spring-boot-starter-data-redis 外，还添加了 commons-pool2 依赖，是因为我们需要使用到连接池。 配置属性 只需要在 application.yaml | properties 中配置如下常用的基本属性即可： spring: data: redis: # 连接地址 host: "localhost" # 端口 port: 6379 # 数据库 database: 0 # 用户名，如果有 # username: # 密码，如果有 # password: # 连接超时 connect-timeout: 5s # 读超时 timeout: 5s # Lettuce 客户端的配置 lettuce: # 连接池配置 pool: # 最小空闲连接 min-idle: 0 # 最大空闲连接 max-idle: 8 # 最大活跃连接 max-active: 8 # 从连接池获取连接 最大超时时间，小于等于0则表示不会超时 max-wait: -1ms 注意，如果你使用的是 spring boot 2. https://springdoc.cn/swagger-two-responses-one-response-code/ Sun, 24 Sep 2023 11:20:14 +0800 https://springdoc.cn/swagger-two-responses-one-response-code/ 1、概览 本文介绍了如何在 API 规范中，为同一个响应定义多个不同的对象，以及如何使用该规范生成 Java 代码和 Swagger 文档。 2、问题陈述 定义两个对象（object）。 Car 对象的属性是 owner 和 plate，两者都是 String。 Bike 对象的属性是 owner 和 speed，speed 是一个 Integer。 它们在 OpenAPI 中的描述如下： Car: type: object properties: owner: type: string plate: type: string Bike: type: object properties: owner: type: string speed: type: integer 我们想描述一个 /vehicle 端点，它将接受 GET 请求，并能返回一个 Car 或一个 Bike。 类似于如下描述： paths: /vehicle: get: responses: '200': # 返回 Car 或 Bike 接下来介绍在 OpenAPI 2 和 3 规范中的不同实现方式。 https://springdoc.cn/java-feign-client-exception-handling/ Sun, 24 Sep 2023 10:39:07 +0800 https://springdoc.cn/java-feign-client-exception-handling/ 1、概览 在 Feign 客户端 中，可以使用 ErrorDecoder 或者 FallbackFactory 来处理异常。 2、Maven 依赖 创建一个 Spring Boot 项目，添加 spring-cloud-starter-openfeign 依赖，该 starter 已经包含了 feign-core 依赖。 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> <version>3.1.3</version> </dependency> 如果你想自定义要使用的 feign-core 的版本，你也可以手动在 pom.xml 文件中添加 feign-core 依赖： <dependency> <groupId>io.github.openfeign</groupId> <artifactId>feign-core</artifactId> <version>11.9.1</version> </dependency> 3、使用 ErrorDecoder 处理异常 通过自定义 ErrorDecoder 来处理异常，可以在出现异常时返回自定义的异常。 如下： public class RetreiveMessageErrorDecoder implements ErrorDecoder { private final ErrorDecoder errorDecoder = new Default(); @Override public Exception decode(String methodKey, Response response) { ExceptionMessage message = null; try (InputStream bodyIs = response. https://springdoc.cn/spring-boot-spel-request-log/ Sat, 23 Sep 2023 16:21:45 +0800 https://springdoc.cn/spring-boot-spel-request-log/ 通常，我们在 Spring Boot 应用中都是用过 AOP 和自定义注解的方式来记录请求日志、操作日志等。 这种方式记录到的日志数据，都是固定的模板数据。如：XXX 删除了用户、XXX 新增了用户、XXX 查询了用户列表 等等。 如果我们想要在日志内容中添加更多的业务信息，如：XXX 删除了用户 ID = xxx 的记录，那么可以通过使用 AOP 和 SpEL 表达式来实现。 SpEL 表达式简介 SpEL（Spring Expression Language） 是 Spring 中的表达式语言，用于在运行时评估和处理表达式。它提供了一种灵活的方式来访问和操作对象的属性、方法和其他表达式。SpEL可以用于配置文件、注解、XML 配置等多种场景，用于实现动态的、可配置的行为。它支持常见的表达式操作，如算术运算、逻辑运算、条件判断、集合操作等，并且可以与 Spring 框架的其他功能整合使用。 通俗理解就是，可以在 Spring 应用中使用 String 定义表达式，在表达式中可以创建、定义对象。以及访问对象的属性、方法，进行逻辑运算等等。最后得到表达式的输出结果！ 一个简单的例子如下： import org.springframework.expression.Expression; import org.springframework.expression.ExpressionParser; import org.springframework.expression.EvaluationContext; import org.springframework.expression.spel.standard.SpelExpressionParser; import org.springframework.expression.spel.support.StandardEvaluationContext; public class Main { public static void main(String[] args) { // 执行上下文 EvaluationContext context = new StandardEvaluationContext(); context.setVariable("param", "World"); // 设置参数到上下文 // 解析器 ExpressionParser parser = new SpelExpressionParser(); // 使用解析器，解析 SpEL 表达式 // 该表达式中定义了字符串 'Hello ' 常量，并且调用它的 . https://springdoc.cn/spring-boot-arr-parameter/ Fri, 22 Sep 2023 15:57:51 +0800 https://springdoc.cn/spring-boot-arr-parameter/ 普通的数组 定义一个简单的 Controller，它接收一个 String[] 类型的数组参数，如下： @RestController @RequestMapping("/demo") public class DemoController { @GetMapping public Object demo (@RequestParam("hobby") String[] hobby) { return hobby; } } Spring Boot 可以直接把以逗号分割的参数封装为集合、数组，例如： $ curl "localhost:8080/demo?hobby=chang,tiao,rap" ["chang","tiao","rap"] 其他框架、程序不一定会根据逗号进行分割。更优雅的方式，也是通用的方式应该是多次声明同名参数，例如： $ curl "localhost:8080/demo?hobby=chang&hobby=tiao&hobby=rap" ["chang","tiao","rap"] 数组也可以替换为 Collection 接口，Spring 都会正确地处理。特别是在一些需要对数组参数去重的场景，推荐使用 Set 作为参数，如下： @GetMapping public Object demo (@RequestParam("hobby") Set<String> hobby) { return hobby; } 发起请求，这一次 rap 值重复传递了 3 次： $ "localhost:8080/demo?hobby=chang&hobby=tiao&hobby=rap&hobby=rap&hobby=rap" ["chang","tiao","rap"] 得益于 Set 自带去重的特性，所以最终 hobby 集合中重复的 rap 值，只保留了一个。 使用 Set 作为参数的时候，默认使用的实现是 java. https://springdoc.cn/spring-boot-replace-deprecated-jdbctemplate-queryforobject-query/ Fri, 22 Sep 2023 13:42:27 +0800 https://springdoc.cn/spring-boot-replace-deprecated-jdbctemplate-queryforobject-query/ 1、概览 在 Spring Boot 2.4.x 以后，JdbcTemplate 中有几个方法注解了 @Deprecated，也就是说被废弃了： query(String sql, @Nullable Object[] args, ResultSetExtractor<T> rse) query(String sql, @Nullable Object[] args, RowCallbackHandler rch) query(String sql, @Nullable Object[] args, RowMapper<T> rowMapper) queryForObject(String sql, @Nullable Object[] args, RowMapper<T> rowMapper); queryForObject(String sql, @Nullable Object[] args, Class<T> requiredType) queryForList(String sql, @Nullable Object[] args, Class<T> elementType) 这些过时的方法都使用对象数组 Object[] args 传递参数。 JdbcTemplate 又提供了一些新的方法来代替它们，新方法使用了 “可变参数”，即 Varargs 传递参数。 本文接下来会讲解一下新旧方法的用法和区别。 2、数据库 使用 H2 内存数据库进行演示，假如我们有一张 student 表，如下： CREATE TABLE student ( student_id INT AUTO_INCREMENT PRIMARY KEY, student_name VARCHAR(255) NOT NULL, age INT, grade INT NOT NULL, gender VARCHAR(10) NOT NULL, state VARCHAR(100) NOT NULL ); -- Student 1 INSERT INTO student (student_name, age, grade, gender, state) VALUES ('John Smith', 18, 3, 'Male', 'California'); -- Student 2 INSERT INTO student (student_name, age, grade, gender, state) VALUES ('Emily Johnson', 17, 2, 'Female', 'New York'); -- 其他 insert 语句 . https://springdoc.cn/sprig-boot-v3-1-4-released/ Fri, 22 Sep 2023 11:04:32 +0800 https://springdoc.cn/sprig-boot-v3-1-4-released/ ⭐ 新特性 在 JavaVersion 枚举中添加 TWENTY_ONE #37364 🐞 Bug 修复 当 SLF4J 和 Logback 在多线程中并行初始化时，由于 SubstituteLoggerFactory 被认为是一个竞争的 LoggerFactory 实现，启动可能会失败 #37484 使用 metadata-url 时，Saml2RelyingPartyAutoConfiguration 会忽略 sign-request #37482 在 DomainSocket 工具中泄漏文件描述符/套接字 #37460 在 WelcomePageHandlerMapping 中，无效的 Accept 头会产生 HTTP 500 #37457 PrivateKeyParser 不支持 ed448、XDH 和 RSA-PSS 密钥 #37422 使用 Gradle 8.3 并配置 Java 工具链语言版本时，“languageVersion is final and cannot be changed” #37380 当 @ConfigurationProperties 注解的记录有多个构造函数时，AOT 处理失败 #37336 使用 Gradle 和 dependency management 插件时，Spring Boot dependency management 对 ehcache 无效 #37270 SslStoreBundle 实现不是不可变的 #37222 解析因使用大写字母而无效的 OCI image 名称的速度非常慢 #37183 生成和消费不同的跟踪传播格式不起作用 #37178 使用除 secp384r1 之外的椭圆曲线时，使用 https 失败 #37169 在 3. https://springdoc.cn/springboot-freemarker/ Fri, 22 Sep 2023 09:44:38 +0800 https://springdoc.cn/springboot-freemarker/ 在前后端分离架构大行其道的今天，模板引擎依然有着重要的地位和不可代替性。 Freemarker 是一款界开源的老牌模板引擎，使用 Java 开发，Spring 官方对 Freemarker 提供了支持。本文将会带你学习如何在 Spring Boot 中整合 Freemarker。 创建项目 在 pom.xml 添加 spring-boot-starter-web 和 spring-boot-starter-freemarker 依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-freemarker</artifactId> </dependency> 编写模板 根据 Spring Boot 约定，模板文件应该放在 src/main/resources 目录下的 templates 目录中。 在 templates 目录中，创建 index 文件夹，用于存放渲染主页的 index.ftl 模板视图，如下： 其中 index.ftl 内容如下： <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>Freemarker</title> </head> <body> Hello ${title}! </body> </html> 如上，模板只是简单地输出了 Model 中的 title 属性。 配置属性 Spring Boot 提供了很多配置属性，可用于在 application.yaml | properties 中定制 Freemarker。 这些属性都以 spring. https://springdoc.cn/spring-webflux-databufferlimitexception/ Thu, 21 Sep 2023 15:53:14 +0800 https://springdoc.cn/spring-webflux-databufferlimitexception/ 1、简介 本文将将会介绍在 Spring WebFlux 应用中出现 DataBufferLimitException 的原因，以及解决办法。 2、原因 在讲解决方案前，先解释一下这个异常的原因。 2.1、DataBufferLimitException 是啥？ Spring WebFlux 限制 了编解码器（codec）中 Buffer 的内存大小，以避免应用出现内存问题。默认情况下，配置为 262,144 字节。如果超出限制，就会导致 DataBufferLimitException 异常。 2.2、编解码器是啥？ spring-web 和 spring-core 模块通过非阻塞 I/O 和 Reactive Stream 背压提供了将字节内容序列化和反序列化为更高级对象的支持。编解码器 提供了一种替代 Java 序列化的方法。其中一个 优点 是，通常对象不需要实现 Serializable 接口。 3、服务端 先看服务端的 DataBufferLimitException 是如何发生的。 3.1、问题复现 尝试向 Spring WebFlux 服务器发送大小为 390 KB 的 JSON 请求体以触发异常。 使用 curl 命令向服务器发送 POST 请求： curl --location --request POST 'http://localhost:8080/1.0/process' \ --header 'Content-Type: application/json' \ --data-binary '@/tmp/390KB.json' 你可以看到，抛出了 DataBufferLimitException 异常： https://springdoc.cn/spring-invoke-cacheable-other-method-same-bean/ Thu, 21 Sep 2023 13:22:29 +0800 https://springdoc.cn/spring-invoke-cacheable-other-method-same-bean/ 1、简介 在 Spring 中可以使用 @Cacheable 注解通过 AOP 技术地轻松为 Bean 中的方法启用缓存功能。但是，当你尝试在 Bean 的其他方法中直接调用 @Cacheable 方法时，缓存功能会失效。 本文将会解释这种情况下缓存功能失效的原因以及解决办法。 2、复现问题 首先，初始化一个启用缓存的 Spring Boot 应用。然后创建一个 MathService，其中的 square 方法注解了 @Cacheable： @Service @CacheConfig(cacheNames = "square") public class MathService { private final AtomicInteger counter = new AtomicInteger(); @CacheEvict(allEntries = true) public AtomicInteger resetCounter() { counter.set(0); return counter; } @Cacheable(key = "#n") public double square(double n) { counter.incrementAndGet(); return n * n; } } 接着，再在 MathService 中创建一个 sumOfSquareOf2 方法，调用两次 square 方法： https://springdoc.cn/spring-boot-security-ssl-bundles/ Thu, 21 Sep 2023 10:33:13 +0800 https://springdoc.cn/spring-boot-security-ssl-bundles/ 1、简介 以前在 Spring Boot 中配置 SSL 非常复杂，主要是证书有很多类型，如：JKS、PKCS #12 或 PEM。每种类型的配置方式又不一样。 幸运的是，Spring Boot 3.1 引入了 SSL Bundle，旨在简化 Spring Boot 中的 SSL 配置。在本教程中，我们将了解什么是 SSL Bundle，以及如何用它简化 Spring Boot 应用中的 SSL 配置。 2、Spring Boot SSL Bundle 通常，我们需要把 SSL 证书转换为可用的 Java 对象。 java.security.KeyStore 对象用于存储证书。 javax.net.ssl.KeyManager 对象用于管理密钥。 javax.net.ssl.SSLContext 对象用于创建安全的套接字连接（Socket Connection）。 每个类都需要更深入的理解和配置，使得整个过程变得繁琐且容易出错。各种 Spring Boot 组件可能还需要深入到不同的抽象层来应用这些设置，给任务增加了另一个难度层级。 SSL Bundle 将所有 SSL 的配置（如 Keystore、证书和私钥）封装成一个易于管理的单元。可以应用于一个或多个网络连接，无论它们是传入连接（嵌入式服务器）还是传出连接（HTTP 客户端）。 SSL Bundle 在 application.yaml 或 application.properties 中，配置属性前缀是 spring.ssl.bundle。 首先从 JKS Bundle 开始，使用 spring.ssl.bundle.jks 来配置 Java Keystore 证书： https://springdoc.cn/spring-boot-cors-filter/ Thu, 21 Sep 2023 09:18:15 +0800 https://springdoc.cn/spring-boot-cors-filter/ 跨域问题每个人都会遇到，特别是在前后端分离的系统中。 如果你正在使用 Spring Boot 开发后端应用，并且浏览器中遇到了跨域问题。类似于如下： Access to fetch at 'http://127.0.0.1/demo' from origin 'https://springdoc.cn' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled. 但是你又不想去了解跨域、CORS 这些到底是个啥，你只想快速地解决这个问题。 那你可以把如下配置类，添加到你的 Spring Boot 应用中，它可以解决 99% 以上的跨域问题： // TODO package 声明 import java.time.Duration; import java.util.Arrays; import java.util.stream.Stream; import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.context.annotation.Bean; import org. https://springdoc.cn/spring-webclient-limit-requests-per-second/ Wed, 20 Sep 2023 16:31:48 +0800 https://springdoc.cn/spring-webclient-limit-requests-per-second/ 1、简介 本文介绍了一些限制 WebClient 并发请求数量的方式。 2、服务端 限制 WebClient 并发请求数量是为了避免服务器因大量并发请求而宕机。有些服务自身也提供了一些限制策略。 2.1、一个简单的 Controller 为了演示，先定义一个简单的 @RestController，它返回固定范围的随机数字： @RestController @RequestMapping("/random") public class RandomController { @GetMapping Integer getRandom() { return new Random().nextInt(50); } } 接下来，我们将模拟一些耗时的操作，并限制并发请求的数量。 2.2、服务器限制并发请求数 修改服务，模拟一个更真实的场景。 首先，限制服务器可接受的并发请求数，并在达到限制时抛出异常。 其次，增加处理响应的延迟，模拟耗时的操作。 创建 Concurrency 用于限制并发数量： public class Concurrency { public static final int MAX_CONCURRENT = 5; static final AtomicInteger CONCURRENT_REQUESTS = new AtomicInteger(); public static int protect(IntSupplier supplier) { try { if (CONCURRENT_REQUESTS.incrementAndGet() > MAX_CONCURRENT) { throw new UnsupportedOperationException("max concurrent requests reached"); } TimeUnit. https://springdoc.cn/spring-using-groovy/ Wed, 20 Sep 2023 15:01:30 +0800 https://springdoc.cn/spring-using-groovy/ 1、概览 Groovy 是一种功能强大的动态 JVM 语言，具有众多特性。在 Spring 中使用 Groovy 可以大大提高应用程序的灵活性和可读性。从 Spring 4 开始 支持基于 Groovy 的配置。 在本教程中，我们将了解 Groovy 与 Spring 结合使用的各种方法。首先介绍了如何使用 Spring 提供的多个选项来创建 Groovy Bean 定义。接下来，了解如何使用 Groovy 脚本加载 Application Context。最后，学习如何使用 XML 和 GroovyScriptEngine 类将 Groovy 作为脚本执行（无需编译）。 2、Maven 依赖 首先，在 pom.xml 中定义 Groovy 依赖： <dependency> <groupId>org.codehaus.groovy</groupId> <artifactId>groovy</artifactId> <version>3.0.12</version> </dependency> 此外，还需要添加 GMavenPlus 插件来编译 Groovy 文件： <build> <plugins> <plugin> <groupId>org.codehaus.gmavenplus</groupId> <artifactId>gmavenplus-plugin</artifactId> <version>1.9.0</version> <executions> <execution> <goals> <goal>addSources</goal> <goal>addTestSources</goal> <goal>generateStubs</goal> <goal>compile</goal> <goal>generateTestStubs</goal> <goal>compileTests</goal> <goal>removeStubs</goal> <goal>removeTestStubs</goal> </goals> </execution> </executions> </plugin> </plugins> </build> 3、Bean 定义 传统上，开发人员通过 XML 配置来声明 Bean。这种方式后来被通过 Java 注解以编程方式定义 Bean 所取代。另一种声明 Bean 的方式是通过 Groovy 脚本。 https://springdoc.cn/spring-boot-pid/ Wed, 20 Sep 2023 09:18:28 +0800 https://springdoc.cn/spring-boot-pid/ PID 是进程标识符（Process Identifier）的缩写。在操作系统中，每个运行的进程都被分配一个唯一的 PID，用于标识进程。PID 通常是一个整数值，可以用来跟踪和管理进程的状态、资源分配以及进程间的通信。 本文将会介绍几种获取 Spring Boot 应用 PID 的方法。 ApplicationPidFileWriter ApplicationPidFileWriter 是 Spring Boot 提供的一个 Listener，它可以在应用启动后把 PID 写入到指定的文件。 它需要在启动前，通过编程式配置到应用中，并且需要在配置文件中指定要写入 PID 的文件。 application.yaml 配置如下： spring: pid: # 写入 PID 的文件，可以是相对路径或绝对路径 file: app.pid # 如果 PID 无法写入，是否抛出异常 fail-on-write-error: true 在启动前，配置 ApplicationPidFileWriter 监听器： import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.boot.context.ApplicationPidFileWriter; @SpringBootApplication public class DemoApplication { public static void main(String[] args) { SpringApplication springApplication = new SpringApplicationBuilder() .listeners(new ApplicationPidFileWriter()) // PID 监听 . https://springdoc.cn/securing-spring-boot-applications-with-ssl/ Tue, 19 Sep 2023 16:15:05 +0800 https://springdoc.cn/securing-spring-boot-applications-with-ssl/ 安全套接字层（SSL）和传输层安全（TLS）是在分层或面向服务的架构中保护系统之间通信的关键组件。在这样的架构中，Spring Boot 应用程序通常接受传入的网络连接或创建传出连接，开发人员的任务是配置应用程序以在这样的安全环境中工作。 如果你曾经使用过 Java 的 Security 和 SSL API，你可能意识到这不是一项特别简单的任务。你可能会在网上复制各种代码片段。有几个因素使得与 SSL 工作变得痛苦。 首先，你可能会收到用于生产环境的 SSL 资源文件，如证书和私钥。你可能需要为预生产测试生成不同的证书（通常使用自签名证书颁发机构）。这些证书通常以 Java Keystore 文件的形式存在，可以是 JKS 或 PKCS #12 格式，或者它们可能是 PEM 编码的文本文件。每种文件类型都需要不同的处理方式。 一旦你有了证书，你需要将其转换为可以传递给 Java Connection API 的形式。麻烦点就在这里，因为 Connection API 可以以多种方式进行配置： 有的要你提供 java.security.KeyStore（Keystore 和 Truststore） 实例。 有的要你提供 javax.net.ssl.KeyManager 和 javax.net.ssl.TrustManager 实例。 有的要你提供 javax.net.ssl.SSLContext 实例。 SSL 也是相当底层的，因此通常需要逐层解除抽象，以使用 java.security 或 java.net.ssl 包中的对象进行配置。例如，如果你想在 Spring RestTemplate 上配置SSL，你需要深入到支持它的 ClientHttpRequestFactory。对于典型的 Spring Boot 应用程序，可能是一个 HttpComponentsClientHttpRequestFactory、OkHttp3ClientHttpRequestFactory 或 SimpleClientHttpRequestFactory。每个 Factory 都提供了不同的配置API。 Spring Boot 配置 SSL 或 TLS 并不是什么新鲜事，但团队决定全面审视当前对 SSL 的支持，寻找改进和扩展支持的机会。我们希望 Spring Boot 3. https://springdoc.cn/spring-enablemethodsecurity-annotation/ Tue, 19 Sep 2023 13:37:40 +0800 https://springdoc.cn/spring-enablemethodsecurity-annotation/ 1、概览 使用 Spring Security，可以为应用配置身份认证和授权，以控制方法（如端点）的访问权限。 在 5.6 之前，使用 @EnableGlobalMethodSecurity 注解是标准的做法，在 5.6 之后，@EnableMethodSecurity 引入了一种更灵活的方法来配置方法安全授权（Method Security）。 在本教程中，我们将通过示例代码了解 @EnableMethodSecurity 如何代替 @EnableGlobalMethodSecurity，以及他们之间的区别。 2、@EnableMethodSecurity 和 @EnableGlobalMethodSecurity 让我们来看看方法授权如何与 @EnableMethodSecurity 和 @EnableGlobalMethodSecurity 配合使用。 2.1、@EnableMethodSecurity 通过 @EnableMethodSecurity，可以看到 Spring Security 为授权类型（Authorization Type）采用基于 Bean 的配置。 我们现在为每种类型都设置了一个配置，而不是全局配置。例如，Jsr250MethodSecurityConfiguration： @Configuration(proxyBeanMethods = false) @Role(BeanDefinition.ROLE_INFRASTRUCTURE) class Jsr250MethodSecurityConfiguration { // ... @Bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) Advisor jsr250AuthorizationMethodInterceptor() { return AuthorizationManagerBeforeMethodInterceptor.jsr250(this.jsr250AuthorizationManager); } @Autowired(required = false) void setGrantedAuthorityDefaults(GrantedAuthorityDefaults grantedAuthorityDefaults) { this.jsr250AuthorizationManager.setRolePrefix(grantedAuthorityDefaults.getRolePrefix()); } } MethodInterceptor 主要包含一个 AuthorizationManager，它现在将 “检查和返回最终决策的 AuthorizationDecision 对象” 的责任委托给适当的实现，这里是 AuthenticatedAuthorizationManager。 https://springdoc.cn/spring-boot-enable-disable-endpoints-at-runtime/ Tue, 19 Sep 2023 10:09:27 +0800 https://springdoc.cn/spring-boot-enable-disable-endpoints-at-runtime/ 1、概览 在 Spring Boot 运行时，出于一些维护目的，我们可能需要动态地启用、禁用某些端点。 在本教程中，我们将学习如何使用 Spring Cloud、Spring Actuator 和 Apache 的 Commons Configuration 等几个常用库在运行时启用和禁用 Spring Boot 端点。 2、项目设置 以下是 Spring Boot 项目的关键设置。 2.1、Maven 依赖 首先，在 pom.xml 文件中添加 spring-boot-starter-actuator 依赖，用于暴露 /refresh 端点： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> <version>2.7.5</version> </dependency> 接下来，添加 spring-cloud-starter 依赖，因为稍后需要使用其 @RefreshScope 注解来重载 Environment 中的属性源： <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter</artifactId> <version>3.1.5</version> </dependency> 还必须在项目 pom.xml 文件的 <dependencyManagement> 中添加 Spring Cloud 的 BOM，以便 Maven 使用兼容版本的 spring-cloud-starter： <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>2021.0.5</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> 最后，由于我们需要在运行时重新加载文件的功能，所以还要添加 commons-configuration 依赖： https://springdoc.cn/spring-boot-gson/ Tue, 19 Sep 2023 08:33:34 +0800 https://springdoc.cn/spring-boot-gson/ GSON 是由谷歌开源的一款 Java JSON 库。特点是轻量，只有一个 JAR，无任何其他依赖。高性能，支持以流式进行序列化/反序列化。并且抽象了基本的 JsonElement、JsonObject、JsonArray、JsonPrimitive 和 JsonNull，可以在无自定义 Java 对象的情况下构建、解析 JSON 对象。 本文将会指导你如何在 Spring Boot 中使用 Gson 代替默认的 Jackson 作为 JSON 序列化/反序列化框架。 添加依赖 在 pom.xml 中添加依赖。 gson 的版本已经被 Spring Boot 管理，所以不需要声明版本号。 <dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> </dependency> 由于 Spring Boot 默认使用 Jackson，所以很多 Spring Boot 的组件、框架默认也会选择用 Jackson 作为 JSON 库。如果你确认项目中，没有其他地方使用到了 Jackson，那么可以从依赖中排除它。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <exclusions> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-json</artifactId> </exclusion> </exclusions> </dependency> 并且，在 @SpringBootApplication 注解中，排除掉 Jackson 的自动装配。 @SpringBootApplication(exclude = { JacksonAutoConfiguration.class }) 配置属性 在 application. https://springdoc.cn/spring-resttemplate-secure-https-service/ Mon, 18 Sep 2023 17:04:30 +0800 https://springdoc.cn/spring-resttemplate-secure-https-service/ 1、概览 在本教程中，我们将学习如何给 RestTemplate 配置 SSL 证书来访问 HTTPS 加密的 REST 服务。 2、设置 要确保 REST 服务的安全，我们需要使用证书和由证书生成的 Keystore。 证书可以从 CA 获取，在本文的示例中，使用的是自签名证书。 我们将使用 Spring 的 RestTemplate 来访问 HTTPS REST 服务。 首先，让我们创建一个 Controller 类 WelcomeController 和一个 /welcome 端点（返回一个简单的字符串响应）： @RestController public class WelcomeController { @GetMapping(value = "/welcome") public String welcome() { return "Welcome To Secured REST Service"; } } 然后，在 src/main/resources 文件夹中添加我们的 keystore： src/main/resources |-keystore |-baeldung.p12 接下来，在 application.properties 文件中添加与 Keystore 相关的属性： server.port=8443 server.servlet.context-path=/ # keystore 的格式 server. https://springdoc.cn/spring-boot-enum-mapping/ Mon, 18 Sep 2023 15:53:04 +0800 https://springdoc.cn/spring-boot-enum-mapping/ 1、概览 在本教程中，我们将学习如何在 Spring Boot 中实现不区分大小写的枚举映射。 2、Spring 默认的枚举映射 在处理请求参数时，Spring 依靠几个内置 Converter 来处理字符串转换。 通常情况下，将枚举作为请求参数时，默认会使用 StringToEnumConverterFactory 将传递的字符串转换为枚举。 该 Converter 会调用 Enum.valueOf(Class, String)，这意味着给定的字符串必须要完全匹配枚举中的常量实例。 例如，让我们来看看 Level 枚举： public enum Level { LOW, MEDIUM, HIGH } 接下来，创建一个使用枚举作为参数的 Handler Method： @RestController @RequestMapping("enummapping") public class EnumMappingController { @GetMapping("/get") public String getByLevel(@RequestParam(required = false) Level level){ return level.name(); } } 使用 CURL 向 http://localhost:8080/enummapping/get?level=MEDIUM 发送一个请求： curl http://localhost:8080/enummapping/get?level=MEDIUM Handler Method 会返回 MEDIUM，即枚举实例 MEDIUM 的名称（name()）。 现在，让我们传递 medium，看看会发生什么： curl http://localhost:8080/enummapping/get?level=medium {"timestamp":"2022-11-18T18:41:11.440+00:00","status":400,"error":"Bad Request","path":"/enummapping/get"} 如你所见，返回了无效请求异常： https://springdoc.cn/spring-cloud-config-remote-properties-override/ Mon, 18 Sep 2023 13:33:24 +0800 https://springdoc.cn/spring-cloud-config-remote-properties-override/ 1、概览 Spring Cloud Config 是 Spring Cloud 全家桶的一个子项目。它通过集中式独立的服务来管理各个服务的配置。Spring Cloud Config 拥有自己的属性管理库，但也可以集成 Git、Consul 和 Eureka 等开源项目。 在本文中，我们将了解在 Spring Cloud Config 中覆盖远程属性值的不同方法，以及 Spring 从 2.4 版本开始强制实施的限制，以及 3.0 版本中的变化。在本教程中，我们使用 Spring Boot 2.7.2。 2、创建 Spring Config Server 使用 Spring Cloud Config 创建外部化的配置服务器。 2.1、创建配置文件 在 application.properties 文件中定义的配置与所有客户端应用共享。也可以为指定应用或指定 Profile 定义特定配置。 首先，创建一个配置文件，其中包含为客户端应用提供的属性。 客户端应用命名为 baeldung，在 /resources/config 文件夹中创建 baeldung.properties 文件。 2.2、添加属性 在 baeldung.properties 文件中添加一些属性，然后在客户端应用中使用这些属性： hello=Hello Jane Doe! welcome=Welcome Jane Doe! 还要在 resources/config/application.properties 文件中添加一个共享属性，Spring 将在所有客户端中共享该属性： shared-property=This property is shared accross all client applications 2. https://springdoc.cn/spring-boot-feignclient-vs-webclient/ Mon, 18 Sep 2023 12:28:14 +0800 https://springdoc.cn/spring-boot-feignclient-vs-webclient/ 1、概览 在本教程中，我们将对 Spring Feign（声明式 REST 客户端）和 Spring WebClient（Spring 5 中引入的响应式 Web 客户端）的优缺点进行比较。 2、阻塞式和非阻塞式客户端 在微服务系统中，服务之间的通常通过 RESTful API 进行通信。因此，需要一个 Web 客户端来执行请求。 接下来，我们将了解阻塞式 Feign 客户端与非阻塞式 WebClient 之间的区别。 2.1、阻塞式 Feign 客户端 Feign 客户端是一种声明式 REST 客户端，能快速、简单地开发 Web 客户端。使用 Feign 时，只需定义接口并对其进行相应注解。然后，Spring 会在运行时生成实际的 Web 客户端实现。 @FeignClient 的实现使用 “每个请求一个线程” 的同步模型。因此，对于每个请求，当前线程会阻塞，直到收到响应为止。如果同时发起多个请求，就要使用大量的线程，每个打开的线程都会占用内存和CPU。 2.2、非阻塞式 WebClient 客户端 WebClient 是 Spring WebFlux 的一部分。它是 Spring Reactive Framework 提供的一种非阻塞解决方案，用于解决 Feign 客户端等同步实现的性能瓶颈。 Feign 客户端会为每个请求创建一个线程并阻塞它，直到收到响应为止，而 WebClient 会执行 HTTP 请求并将 “等待响应” 任务添加到队列中。随后，在收到响应后，从队列中执行 “等待响应” 任务，最后将响应发送给 Subscriber （订阅者）函数。 Reactive 框架实现了由 Reactive Streams API 支持的事件驱动架构。正如我们所看到的，这使我们能够编写只需要最少数量的阻塞线程就能执行 HTTP 请求的服务。 https://springdoc.cn/jdbctemplate-return-auto-key/ Mon, 18 Sep 2023 08:54:33 +0800 https://springdoc.cn/jdbctemplate-return-auto-key/ JdbcTemplate 是由 spring-jdbc 提供的一个 JDBC 工具类模块，可以快速地对数据库进行 CURD 操作。 本文将会教你如何在使用 JdbcTemplate 执行 INSERT 操作时获取到自增ID。 项目设置 创建任意 spring boot 项目。添加 mysql-connector-j 以及 spring-boot-starter-jdbc 依赖。 你可以通过 start.springboot.io 快速创建此示例项目。 <dependency> <groupId>com.mysql</groupId> <artifactId>mysql-connector-j</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> 配置数据源 在 application.yaml 中配置基础的数据源信息。 spring: datasource: type: com.zaxxer.hikari.HikariDataSource driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowMultiQueries=true username: root password: root 配置 JdbcTemplate 通过配置类，注册 JdbcTemplate Bean。 import javax.sql.DataSource; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.jdbc.core.JdbcTemplate; @Configuration public class JdbcTemplateConfiguration { @Bean public JdbcTemplate jdbcTemplate (DataSource dataSource) { return new JdbcTemplate(dataSource); } } 创建示例表 CREATE TABLE `users` ( `id` int unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID', `account` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '账户', `create_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', `name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '用户名称', PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='系统用户'; 其中 id 字段是自增的。 https://springdoc.cn/spring-reinitialize-singleton-bean/ Sun, 17 Sep 2023 10:55:07 +0800 https://springdoc.cn/spring-reinitialize-singleton-bean/ 1、概览 在本教程中，我们将了解如何在运行时重新初始化 Spring Context 中的 Singleton Bean。 默认情况下，Singleton Scope Bean 不会在应用生命周期中重新初始化。不过，有时可能需要重新创建 Bean，例如在需要更新属性时。我们将介绍几种实现此目的的方法。 2、示例 一个小示例。创建一个 Bean，从配置文件中读取属性保存在内存中。如果配置文件中的属性值被修改，那么 Bean 就要重新加载配置。 2.1、Singleton Bean 首先创建 ConfigManager 类： @Service("ConfigManager") public class ConfigManager { private static final Log LOG = LogFactory.getLog(ConfigManager.class); private Map<String, Object> config; private final String filePath; public ConfigManager(@Value("${config.file.path}") String filePath) { this.filePath = filePath; initConfigs(); } private void initConfigs() { Properties properties = new Properties(); try { properties.load(Files.newInputStream(Paths.get(filePath))); } catch (IOException e) { LOG.error("Error loading configuration:", e); } config = new HashMap<>(); for (Map. https://springdoc.cn/spring-cloud-gateway-rate-limit-by-client-ip/ Sat, 16 Sep 2023 11:26:42 +0800 https://springdoc.cn/spring-cloud-gateway-rate-limit-by-client-ip/ 1、简介 在本教程中，我们将学习如何在 Spring Cloud Gateway 中根据客户端的实际 IP 地址来限制请求速率。 简而言之，我们将在路由上设置 RequestRateLimiter Filter，然后配置网关根据 IP 地址来限制客户端的请求。 2、路由配置 首先，我们需要配置 Spring Cloud Gateway 以对特定路由进行速率限制。为此，我们将使用由 spring-boot-starter-data-redis-reactive 实现的经典 令牌桶（Token Bucket） Rate Limiter。简而言之， Rate Limiter 创建一个带有唯一 Key 的 Bucket，该 Key 用于标识 Bucket 自身，并具有固定的初始 Token 容量，随时间自动生成 Token。然后，对于每个请求，Rate Limiter 会获取其关联的 Bucket，并试图减少其 Bucket 中的一个 Token。如果 Bucket 中的 Token 数量不足，将拒绝传入的请求。 在分布式系统中，我们希望所有系统对同一客户端的请求都采用相同的限速策略。所以，我们使用分布式缓存 Redis 来存储 Bucket。在本例中，我们预先配置了一个 Redis 实例。 接下来，配置一个带有 Rate Limiter 的路由。监听 /example 端点，并将请求转发至 http://example.org： @Bean public RouteLocator myRoutes(RouteLocatorBuilder builder) { return builder.routes() .route("requestratelimiter_route", p -> p . https://springdoc.cn/spring-boot-request-add-header/ Sat, 16 Sep 2023 10:43:58 +0800 https://springdoc.cn/spring-boot-request-add-header/ HTTP 请求头一般都是由客户端设置，服务端获取，用以处理业务。但是偶尔也有一些需求，需要服务端对一些请求，添加自定义的请求头。例如：统一为所有请求添加一个名为 X-Requested-Id 的请求头，用于跟踪不同请求。 Servlet 中的请求对象 jakarta.servlet.http.HttpServletRequest 并未提供设置 Header 的方法。 但是，但是通过一些方法，可以实现。本教程将会教你如何在 Spring Boot 应用中添加自定义请求头到 HttpServletRequest。 思路 既然可以从 HttpServletRequest 获取到 Header，那它一定是把 Header 存储在了某个地方。我们只要找到 HttpServletRequest 存储 Header 的容器，就可以对其进行添加、编辑、删除操作。 不同 HttpServletRequest 的实现中，对 Header 的存储方式不一定一样。目前，在 Spring Boot 中最流行的 Servlet 实现就是 Tomcat 和 Undertow，所以下文将会针对这两个服务器进行讲解。 示例应用 创建一个 Spring Boot 应用。我们要在 Filter 中为所有请求添加一个 X-Requested-Id 请求头，并在 Controller 中获取并返回。 Controller 如下： import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import jakarta.servlet.http.HttpServletRequest; @RestController @RequestMapping("/demo") public class DemoController { @GetMapping public String getHeaders (HttpServletRequest request) { // 获取 X-Requested-Id Header 值 String requestedId = request. https://springdoc.cn/springdoc-openapi-form-login-and-basic-authentication/ Fri, 15 Sep 2023 13:44:50 +0800 https://springdoc.cn/springdoc-openapi-form-login-and-basic-authentication/ 1、概览 Springdoc-OpenAPI 是一个为 Spring Boot 应用程序自动生成 API 文档的框架。它实现了 OpenAPI 3 规范，使用它，通过 UI 界面就可以与 API 进行交互，非常方便。 在本教程中，我们将学习如何使用 Spring Security 通过表单登录和 Basic Authentication 来认证 springdoc 中的端点访问。 2、项目设置 创建一个 Spring Boot Web 应用程序，该应用程序将通过 Spring Security 保护 API，并使用 Springdoc 生成文档。 2.1、依赖 首先添加 springdoc-openapi-ui，它整合了 Swagger-UI，用于提供 UI 界面： http://localhost:8080/swagger-ui.html 其次，添加 springdoc-openapi-security，用于为 Spring Security 提供支持： <dependency> <groupId>org.springdoc</groupId> <artifactId>springdoc-openapi-ui</artifactId> <version>1.6.13</version> </dependency> <dependency> <groupId>org.springdoc</groupId> <artifactId>springdoc-openapi-security</artifactId> <version>1.6.13</version> </dependency> 2.2、示例 API 创建一个示例 REST Controller，Springdoc 会为其生成文档。 此外，我们将通过 Swagger-UI 来演示与 FooController 中受保护（需要认证）的端点进行交互。 @RestController @RequestMapping(value = "foos", produces = MediaType. https://springdoc.cn/webclient-stream-large-byte-array-to-file/ Fri, 15 Sep 2023 12:42:29 +0800 https://springdoc.cn/webclient-stream-large-byte-array-to-file/ 1、简介 在本教程中，我们将学习如何使用 WebClient 从服务器以流式下载一个大文件。我们通过创建一个简单的 Controller 和两个客户端进行演示。最后，我们将了解如何以及何时使用 Spring 的 DataBuffer 和 DataBufferUtils 工具类。 2、服务器 创建一个可以下载文件的简单 Controller。 首先，构建一个 FileSystemResource，传递一个文件路径，然后将其封装为 ResponseEntity 的 body： @RestController @RequestMapping("/large-file") public class LargeFileController { @GetMapping ResponseEntity<Resource> get() { return ResponseEntity.ok() .body(new FileSystemResource(Paths.get("/tmp/large.dat"))); } } 其次，我们需要生成下载所用的示例文件，文件内容并不重要，所以我们使用 fallocate 在磁盘上生成一个指定大小的“空”内容文件。如下： fallocate -l 128M /tmp/large.dat 然后就可以开始编写客户端了。 3、WebClient 使用 ExchangeStrategies 处理大文件 先用一个简单而有限的 WebClient 下载文件。使用 ExchangeStrategies 来提高 exchange() 操作的可用内存限制。这样，就能操作更多字节，但仍受限于 JVM 可用的最大内存。 使用 bodyToMono() 从服务器获取 Mono<byte[]>： public class LimitedFileDownloadWebClient { public static long fetch(WebClient client, String destination) { Mono<byte[]> mono = client. https://springdoc.cn/spring-boot-fix-the-no-main-manifest-attribute/ Fri, 15 Sep 2023 10:40:00 +0800 https://springdoc.cn/spring-boot-fix-the-no-main-manifest-attribute/ 1、概览 当我们在执行 Spring Boot JAR 文件时候，可能会遇到 “jar中没有主清单属性”（no main manifest attribute）错误。这是因为我们在 MANIFEST.MF 文件中缺少了 Main-Class 元数据属性的声明，该文件位于 META-INF 文件夹下。 在本教程中，我们将重点介绍造成这一问题的原因以及如何解决。 TL;DR 出现这个问题的原因，八成是你忘记在 pom.xml 中添加 spring-boot-maven-plugin 插件了，添加即可。如下： <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> 2、问题的出现 一般来说，从 Spring Initializr 获取 pom.xml 不会有任何问题。不过，如果我们是手动创建项目，自己在 pom.xml 中添加 spring-boot-starter-parent 依赖，可能会遇到这个问题。 我们可以尝试以 mvn clean package 的方式来构建应用，以重现这个问题： $ mvn clean package 运行 jar 时，我们会遇到错误： $ java -jar target\spring-boot-artifacts-2.jar no main manifest attribute, in target\spring-boot-artifacts-2.jar 在此示例中，MANIFEST.MF 文件的内容为： Manifest-Version: 1.0 Archiver-Version: Plexus Archiver Created-By: Apache Maven 3. https://springdoc.cn/spring-resttemplate-uri-variables-encode/ Fri, 15 Sep 2023 09:45:37 +0800 https://springdoc.cn/spring-resttemplate-uri-variables-encode/ 1、概览 我们经常遇到的一个编码问题是，URI 变量中包含一个加号（+）。例如，如果我们的 URI 变量值为 http://localhost:8080/api/v1/plus+sign，那么加号将被编码为空格，这可能会导致意外的服务器响应。 在本教程中，我们将学习如何在 Spring 的 RestTemplate 上对 URI 变量进行编码。 让我们来看看解决这个问题的几种方法。 2、项目设置 创建一个使用 RestTemplate 进行 API 调用的小项目。 2.1、Spring Web 依赖 在 pom.xml 中添加 Spring Web Starter 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> 或者，可以使用 Spring Initializr 生成项目并添加依赖。 2.2、RestTemplate Bean 创建一个 RestTemplate Bean： @Configuration public class RestTemplateConfig { @Bean public RestTemplate restTemplate() { return new RestTemplate(); } } 3、 调用 API 创建一个 service 类，调用公共 API http://httpbin.org/get。 API 会返回一个包含请求参数的 JSON 响应。例如，如果我们在浏览器上访问 URL https://httpbin. https://springdoc.cn/spring-boot-undertow/ Fri, 15 Sep 2023 08:31:41 +0800 https://springdoc.cn/spring-boot-undertow/ Spring Boot 默认使用 Tomcat 作为嵌入式 Servlet 服务器，它是由 Apache 软件基金会下 Jakarta 项目开发的 Servlet 容器，被广泛用于部署和运行 Java Web 应用程序。特点是轻量级、易于安装和配置，并且具有良好的可扩展性和性能 本文将会介绍另一款优秀的 Servlet 容器，Undertow。以及如何在 Spring Boot 中用它来替换 Tomcat 作为嵌入式服务器。 Undertow Undertow 是一个轻量级的、高性能的 Java Web 服务器，由 JBoss 开发并开源。它是基于非阻塞（non-blocking）的I/O模型，具有低资源消耗和高并发处理能力。 Undertown 的优势如下： 支持 HTTP/2：Undertow 开箱即支持 HTTP/2，无需重写启动类路径。 支持 HTTP Upgrade：允许通过 HTTP 端口复用多种协议。 支持 Web Socket：Undertow 提供对 Web Sockets 的全面支持，包括 JSR-356 支持。 Servlet 4.0：Undertow 支持 Servlet 4.0，包括对嵌入式 Servlet 的支持。还可以在同一部署中混合使用 Servlet 和原生 undertow 非阻塞 handler。 可嵌入式：只需几行代码，即可将 Undertow 嵌入应用程序或独立运行。 灵活性：Undertow 通过链式 handler 进行配置，可以根据需求灵活地添加功能。 在很多场景的测试下， Undertow 的性能都高于 Tomcat。天生适合作为 Spring Boot 应用的嵌入式服务器！ https://springdoc.cn/spring-v6-0-12-released/ Thu, 14 Sep 2023 17:31:02 +0800 https://springdoc.cn/spring-v6-0-12-released/ ⭐ 新特性 ArithmeticException：在 @Scheduled(fixedDelay = Long.MAX_VALUE, timeUnit = TimeUnit.MINUTES) 上 long 溢出 #31210 对 RequestResponseBodyMethodProcessor 中的 resolveArgument 方法进行优化 #31175 更新 BeanValidationBeanRegistrationAotProcessor 中 validation exception 的日志级别 #31147 跳过在 PathMatchingResourcePatternResolver 中搜索不存在的目录。#31111 在 Argument[Type]PreparedStatementSetter 的 doSetValue() 中为 argValue 添加 @Nullable #31086 优化 StringUtils 中的 whitespace 检查 #31067 使用 simple JPARepository 时缺少代理提示 #31050 为 ReactiveAdapterRegistry 中的现有 adapter 注册 override #31047 DefaultListableBeanFactory#getBeanNamesForType 在解析 FactoryBean 时未考虑目标类型 #30987 让 spring-core 访问 org.jboss.vfs，以便在 WildFly 上支持 VfsUtils #30973 当 contentLength 可用时，在 StringHttpMessageConverter 中使用 readNBytes #30942 当数组长度不大于 1 时，跳过数组排序 #30934 避免对每个 SseEventBuilder 条目进行刷新 #30912 使用 protected 修饰 DefaultGenerationContext(DefaultGenerationContext, String) 构造函数 #30895 在 Spring MVC 中的 AbstractResourceResolver 子类中添加缺失的 @Nullable 注解 #30893 创建 scope Bean 实例时的性能瓶颈 #30883 对同一 Bean 类中的多个 @Autowired 方法进行确定性的 Bean 初始化 #30359 优化 ClassUtils#getMostSpecificMethod #30272 Hibernate native 查询代理缺少 native 提示 #29603 检查异常原因以支持 @PropertySource(ignoreResourceNotFound) #22276 调整 PayloadMethodArgumentResolver 中的验证元数据处理方式 #21852 🐞 Bug 修复 Spring Boot 启动失败 does not reside in the file system: manifoldclass://622488023/. https://springdoc.cn/spring-retry-kafka-consumer/ Thu, 14 Sep 2023 14:11:25 +0800 https://springdoc.cn/spring-retry-kafka-consumer/ 1、概览 本文将会带你学习在 Spring 应用中实现 Kafka Consumer 重试消费的 2 种方式，及其优缺点。 关于如何在 Spring 中整合 Kafka 的细节，请参阅 这里。 2、项目设置 创建一个新的 Spring Boot 项目，并添加 spring-kafka 依赖： <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>3.0.1</version> </dependency> 创建一个对象： public class Greeting { private String msg; private String name; // 构造函数、get、set 方法省略 } 3、Kafka Consumer Kafka Consumer（消费者）是从 Kafka 集群中读取数据的客户端应用程序。它订阅一个或多个 topic，并消费已发布的消息。Producer （生产者）向 topic 发送消息，topic 是存储和发布记录的类别名称。topic 被分为多个分区，以便横向扩展。每个分区都是一个不可更改的消息序列。 Consumer 可以通过指定偏移量（即消息在分区中的位置）来读取特定分区中的消息。Ack（确认）是消费者发送给 Kafka broker 的消息，表示它已成功处理了一条记录。一旦 ACK 被发送，消费者偏移量（consumer offset）将会被更新。 这将确保消息已被消费，并且不会再次传递给当前 Listener。 3.1、Ack 模式 Ack 模式决定了 broker 何时更新消费者偏移量（consumer offset）。 https://springdoc.cn/spring-convert-byte-array-to-multipartfile/ Thu, 14 Sep 2023 13:25:10 +0800 https://springdoc.cn/spring-convert-byte-array-to-multipartfile/ 1、概览 MutlipartFile 是 Spring 提供的一个接口，用于接收 multipart 请求中的文件参数。Spring 没有为其提供任何默认实现，但提供了一个用于测试的实现。 在本教程中，我们将学习如何将字节数组转换为 MultipartFile。 2、实现 MultipartFile 接口 让我们创建自己的 MultipartFile 接口实现，并封装传入的字节数组： public class CustomMultipartFile implements MultipartFile { private byte[] input; @Override public String getName() { return null; } @Override public String getOriginalFilename() { return null; } @Override public String getContentType() { return null; } // 下一个代码段中定义了接口的其他方法 } 我们在类中定义了一个 byte[] 属性，存储传入的字节数组。接口中定义的其他几个描述性方法，可以根据需求来实现。这里默认返回 null。 剩余的几个接口方法是必须要实现的，如下： public class CustomMultipartFile implements MultipartFile { // 前一段儿代码省略... @Override public boolean isEmpty() { return input == null || input. https://springdoc.cn/spring-6-ahead-of-time-optimizations/ Thu, 14 Sep 2023 12:41:14 +0800 https://springdoc.cn/spring-6-ahead-of-time-optimizations/ 1、概览 Spring 6 提供了一项新功能，有望优化应用程序的性能： Ahead-of-Time（AOT） 编译支持。 在本文中，我们将了解 Spring 6 中 AOT 优化功能的工作原理、优点以及使用方法。 2、AOT 编译 2.1、JIT 编译器 对于最常用的 Java 虚拟机（JVM），如 Oracle 的 HotSpot JVM 和 OpenJDK，当我们编译源代码（.java 文件）时，生成的字节码存储在 .class 文件中。这样，JVM 就会使用 JIT（Just-In-Time，即时编译） 编译器将字节码转换为机器码。 此外，JIT 编译涉及 JVM 对字节码的解释，以及在运行时将频繁执行的代码动态编译为本地机器码。 2.2、AOT 编译器 Ahead-of-Time（AOT，提前编译或预编译）是一种在应用程序运行前将字节码预编译为本地机器码的技术。 Java 虚拟机（JVM）通常不支持这一功能。不过，甲骨文已在 OpenJDK 项目中发布了一项针对 HotSpot JVM 的实验性 AOT 功能，名为 “GraalVM Native Image”，允许进行 AOT 编译。 预编译代码后，计算机处理器可直接执行代码，无需 JVM 解释字节码，从而缩短了启动时间。 关于 AOT 编译器的更多细节可以参考 官方文档。 3、Spring 6 中的 AOT 支持 3.1、AOT 编译优化 在构建 Spring 6 应用程序时，我们需要考虑三种不同的运行时选项： https://springdoc.cn/spring-boot-logback-log4j2/ Thu, 14 Sep 2023 09:19:12 +0800 https://springdoc.cn/spring-boot-logback-log4j2/ 1、概览 日志是系统中的一个重要组件。Spring Boot 支持 Logback 和 Log4j2 日志框架，并且提供了一些扩展，可用于高级配置。 在本教程中，我将带你学习如何在 Spring Boot 中使用 Logback 和 Log4j2 的扩展进行高级的日志配置。 2、Logback 扩展 Spring Boot 默认使用 Logback 进行日志记录。在本节中，我们将了解 Logback 的一些扩展，以进行高级配置。 注意：Spring Boot 建议使用 logback-spring.xml 作为 Logback 的配置文件名称，而不是默认的 logback.xml。因为 logback.xml 配置文件会被 Logback 默认加载，它会比 Spring 更早地加载进系统，所以我们不能在标准的 logback.xml 中使用扩展， 2.1、Maven 依赖 要使用 Logback，我们需要在 pom.xml 中添加 logback-classic 依赖项。 spring-boot-starter-web 依赖已经包含了它，所以不需要额外导入 logback-classic： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> 2.2、基本日志 首先，在 Spring Boot main 类中输出一些示例日志： @SpringBootApplication public class SpringBootLogbackExtensionsApplication { private static final Logger logger = LoggerFactory. https://springdoc.cn/sprig-boot-cookie-samesite/ Wed, 13 Sep 2023 17:08:13 +0800 https://springdoc.cn/sprig-boot-cookie-samesite/ SameSite 是一个用于增强 Web 应用程序安全性的 Cookie 机制。它定义了浏览器在发送跨站请求时是否应该附加 Cookie。旨在防止跨站请求伪造（CSRF）攻击和某些类型的跨站信息泄露攻击。 SameSite 属性是可选的，它有三个可选值： Strict（严格模式）：在严格模式下，浏览器只会在用户访问与 Cookie 关联的站点时发送 Cookie。如果请求来自其他站点（包括跨站请求），浏览器将不会发送 Cookie。这样可以有效地防止跨站请求伪造攻击。 Lax（宽松模式）：在宽松模式下，大多数情况下，浏览器只会在用户访问与 Cookie 关联的站点时发送 Cookie。但是，如果用户从外部站点通过 GET 方法访问当前站点的 URL，浏览器会发送 Cookie。这样可以在某些常见的使用情况下保持用户体验，同时仍然提供一定程度的安全性。总结如下： 请求类型 示例 正常情况 Lax 链接 <a href=...></a> 发送 Cookie 发送 Cookie 预加载 <link rel=prerender href=.../> 发送 Cookie 发送 Cookie GET 表单 <form method=GET action=...> 发送 Cookie 发送 Cookie POST 表单 <form method=POST action=...> 发送 Cookie 不发送 iframe <iframe src=...></iframe> 发送 Cookie 不发送 AJAX $.get(...) 发送 Cookie 不发送 Image <img src=. https://springdoc.cn/spring-6-http-interface/ Wed, 13 Sep 2023 15:38:07 +0800 https://springdoc.cn/spring-6-http-interface/ 1、概览 在 Spring 6 和 Spring Boot 3 中，我们可以使用 Java 接口来定义声明式的远程 HTTP 服务。这种方法受到 Feign 等流行 HTTP 客户端库的启发，与在 Spring Data 中定义 Repository 的方法类似。 在本教程中，我们将首先了解如何定义 HTTP 接口，以及可用的 exchange 方法注解和支持的方法参数和返回值。接着，学习如何创建一个实际的 HTTP 接口实例，即执行所声明 HTTP exchange 的代理客户端。 最后，我们将介绍如何对声明式 HTTP 接口及其代理客户端进行异常处理和测试。 2、HTTP 接口 声明式 HTTP 接口包括用于 HTTP exchange 的注解方法。我们可以通过使用带注解的 Java 接口来简单地表达远程 API 的细节，然后让 Spring 生成实现该接口并执行 exchange 的代理。这有助于减少样板代码的编写。 2.1、Exchange 方法 @HttpExchange 是我们可以应用于 HTTP 接口及其 exchange 方法的根注解。如果我们将其应用于接口层，那么它就会应用于所有 exchange 方法。这对于指定所有接口方法的共同属性（如 content type 或 URL 前缀）非常有用。 所有 HTTP 方法都有对应的注解： @GetExchange 用于 HTTP GET 请求。 @PostExchange 用于 HTTP POST 请求。 @PutExchange 用于 HTTP PUT 请求。 @PatchExchange 用于 HTTP PATCH 请求。 @DelectExchange 用于 HTTP DELETE 请求。 让我们使用不同的 HTTP 方法注解，来为远程 API 定义一个声明式的 HTTP 接口： https://springdoc.cn/spring-boot-opentelemetry-setup/ Wed, 13 Sep 2023 13:15:58 +0800 https://springdoc.cn/spring-boot-opentelemetry-setup/ 1、概览 在本教程中，我们将学习如何在 Spring Boot 应用中整合 OpenTelemetry 。以及如何配置 OpenTelemetry 来追踪请求链路，并将其发送到中央系统以监控请求。 2、OpenTelemetry 简介 OpenTelemetry（Otel）是一组标准化的工具（与供应商无关）、API 和 SDK。它是一个 CNCF 孵化项目，是 OpenTracing 和 OpenCensus 项目的合并产物。 OpenTracing 用于向可观测性后端发送 telemetry（遥测）数据。OpenCensus 项目提供了一套特定于语言的库，开发人员可以用它来检测自己的代码，并将其发送到任何受支持的后端。Otel 使用与其前身项目相同的 trace 和 span 概念来表示微服务间的请求链路。 OpenTelemetry 允许我们检测、生成和收集 telemetry 数据，这有助于分析应用程序的行为或性能。telemetry 数据包括日志、指标和链路跟踪。 使用 Otel SDK，我们可以轻松地覆盖或添加更多属性到链路跟踪中。 让我们通过一个例子来深入了解一下。 3、示例应用 假设我们需要构建两个微服务，其中一个服务与另一个服务交互。 3.1、Maven 依赖 首先，我们将创建 Spring Boot Web 项目，并在两个应用中包含以下 Spring 和 OpenTelemetry 依赖项： spring-cloud-starter-sleuth、spring-cloud-sleuth-otel-autoconfigure 和 opentelemetry-exporter-otlp 将自动捕获链路跟踪并导出到任何支持的 collector。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-sleuth</artifactId> <exclusions> <exclusion> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-sleuth-brave</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org. https://springdoc.cn/spring-get-current-applicationcontext/ Wed, 13 Sep 2023 12:49:34 +0800 https://springdoc.cn/spring-get-current-applicationcontext/ 1、概览 在这本教程中，我们将了解如何在 Spring 应用中获取当前的 ApplicationContext。 2、ApplicationContext ApplicationContext 代表 Spring IoC 容器，其中包含应用程序创建的所有 Bean。它负责实例化、配置和创建 Bean。此外，它还从 XML 或 Java 中提供的配置元数据中获取 Bean 的信息。 ApplicationContext 是 BeanFactory 的子接口。除了 BeanFactory 的功能外，它还包括消息解析和国际化、资源加载和事件发布等功能。此外，它还具有加载多个 context 的功能。 每个 Bean 都是在容器启动后实例化的。 我们可能希望使用此容器访问应用中的其他 Bean 和资源。我们将学习两种在 Spring 应用中获取当前 ApplicationContext 的方法。 3、ApplicationContext Bean 获取当前 ApplicationContext 的最简单方法是使用 @Autowired 注解将其注入到我们的 Bean 中。 首先，声明实例变量，并使用 @Autowired 对其进行注解： @Component public class MyBean { @Autowired private ApplicationContext applicationContext; public ApplicationContext getApplicationContext() { return applicationContext; } } 也可以使用 @Inject 来代替 @Autowired。 https://springdoc.cn/microservices-with-spring-boot-3-and-spring-cloud/ Wed, 13 Sep 2023 10:19:54 +0800 https://springdoc.cn/microservices-with-spring-boot-3-and-spring-cloud/ Spring Boot 3.0 已于 2022 年 11 月底全面 发布。本文将教你如何使用 Spring Boot 3 和 Spring Cloud 组件构建微服务。 总的来说，本文将涉及以下主题： 在云原生开发中使用 Spring Boot 3。 使用 Spring Cloud Netflix Eureka 为所有微服务提供服务发现功能。你可能想说 “在还用 Eureka？” - 是的，Eureka 还在。它是 Spring Cloud 中最后一个可用的 Netflix 微服务组件。 使用 Spring Cloud OpenFeign 进行服务间通信。 使用 Spring Cloud Config 作为分布式配置中心。 使用 Spring Cloud Gateway 作为网关，其中包括使用 Springdoc 项目创建全局 OpenAPI 文档。 使用 Micrometer OpenTelemetry 和 Zipkin 采集链路追踪。 从 Spring Boot 2 迁移到 Spring Boot 3 并不是太麻烦，具体变更的细节和迁移方法可以参考 这篇文章。 https://springdoc.cn/spring-boot-jdbcclient-tutorial/ Wed, 13 Sep 2023 09:01:13 +0800 https://springdoc.cn/spring-boot-jdbcclient-tutorial/ Spring 6.1 引入了新的 JdbcClient API，它是 JdbcTemplate 的封装，可使用 fluent 风格的 API 执行数据库操作。 本文将会带你学习如何使用 JdbcClient 以简化的方式实现各种数据库操作。 首先，访问 https://start.springboot.io，选择 Spring JDBC、PostgreSQL Driver、Flyway Migration 和 Testcontainers starter，创建一个 Spring Boot 应用程序。 注：在撰写本文时，Spring Boot 3.2.0-M2 已发布，因此我们将选择 3.2.0 (M2) 作为 Spring Boot 版本。 创建 Bookmark 类 先创建一个表示书签的 Java record，如下所示： import java.time.Instant; public record Bookmark(Long id, String title, String url, Instant createdAt) {} 创建 Flyway 迁移脚本 在 src/main/resources/db/migration 目录下添加以下迁移脚本。 V1__create_tables.sql： create table bookmarks ( id bigserial primary key, title varchar not null, url varchar not null, created_at timestamp ); 使用 JdbClient 执行 CRUD 操作 使用 JdbcClient API 在 Bookmark 类上实现 CRUD 操作。 https://springdoc.cn/spring-boot-websocket/ Tue, 12 Sep 2023 13:55:30 +0800 https://springdoc.cn/spring-boot-websocket/ WebSocket 是一种基于 TCP 协议的全双工通信协议，它允许客户端和服务器之间建立持久的、双向的通信连接。相比传统的 HTTP 请求 - 响应模式，WebSocket 提供了实时、低延迟的数据传输能力。通过 WebSocket，客户端和服务器可以在任意时间点互相发送消息，实现实时更新和即时通信的功能。WebSocket 协议经过了多个浏览器和服务器的支持，成为了现代 Web 应用中常用的通信协议之一。它广泛应用于聊天应用、实时数据更新、多人游戏等场景，为 Web 应用提供了更好的用户体验和更高效的数据传输方式。 本文将会指导你如何在 Spring Boot 中整合、使用 WebSocket，以及如何在 @ServerEndpoint 类中注入其他 Bean 依赖 。 在 Spring Boot 中使用 WebSocket 有 2 种方式。第 1 种是使用由 Jakarta EE 规范提供的 Api，也就是 jakarta.websocket 包下的接口。第 2 种是使用 spring 提供的支持，也就是 spring-websocket 模块。前者是一种独立于框架的技术规范，而后者是 Spring 生态系统的一部分，可以与其他 Spring 模块（如 Spring MVC、Spring Security）无缝集成，共享其配置和功能。 2 种方式各有优劣，你可以按需选择。本文将使用第 1 种方式，也就是使用 jakarta.websocket 来开发 WebSocket 应用。 软件版本： Spring Boot：3.1.3 在 Spring Boot 中整合 WebSocket 添加依赖 在 pom. https://springdoc.cn/spring-boot-rest-api-best-practices-part-4/ Tue, 12 Sep 2023 12:40:59 +0800 https://springdoc.cn/spring-boot-rest-api-best-practices-part-4/ 在 “Spring Boot REST API 最佳实践” 系列教程的前几章中，我们已经学习了如何实现 CRUD 操作。在本章节教程中，我们将了解如何为 API 实现异常处理。 Spring Boot REST API 最佳实践 - 第一章：实现 Get Collection API Spring Boot REST API 最佳实践 - 第二章：实现 Create 和 Update API Spring Boot REST API 最佳实践 - 第三章：实现 FindById 和 DeleteById API Spring Boot REST API 最佳实践 - 第四章：REST API 的异常处理（本文） 你可以在此 GitHub 仓库中找到本教程的示例代码。 如 第三章节 所述，如果 Controller 中的请求处理方法抛出异常，Spring Boot 将使用默认的异常处理机制进行处理并返回响应。 如果你只关心在抛出异常时返回正确的 HTTP 状态码，你可以异常类上使用 @ResponseStatus 注解来指定使用哪个 HTTP 状态码，而不是默认的 INTERNAL_SERVER_ERROR - 500。 https://springdoc.cn/spring-boot-rest-api-best-practices-part-3/ Tue, 12 Sep 2023 12:20:10 +0800 https://springdoc.cn/spring-boot-rest-api-best-practices-part-3/ 在本章节教程中，我们将了解如何实现 FindById 和 DeleteById API 端点。 Spring Boot REST API 最佳实践 - 第一章：实现 Get Collection API Spring Boot REST API 最佳实践 - 第二章：实现 Create 和 Update API Spring Boot REST API 最佳实践 - 第三章：实现 FindById 和 DeleteById API（本文） Spring Boot REST API 最佳实践 - 第四章：REST API 的异常处理 你可以在此 GitHub 仓库中找到本教程的示例代码。 实现 GET /api/bookmarks/{id} API 端点 我们希望实现一个根据指定 id 获取单个资源的 API 端点，如果找到，以 HTTP 状态码 200 返回。如果未找到，则返回 HTTP 状态码 404，可选择返回包含异常信息的响应体。 实现 GET /api/bookmarks/{id} API 端点，如下： https://springdoc.cn/spring-boot-rest-api-best-practices-part-2/ Tue, 12 Sep 2023 09:58:43 +0800 https://springdoc.cn/spring-boot-rest-api-best-practices-part-2/ 在本章节教程中，我将介绍我们在实现创建和更新 API 端点时应遵循的一些最佳实践。 Spring Boot REST API 最佳实践 - 第一章：实现 Get Collection API Spring Boot REST API 最佳实践 - 第二章：实现 Create 和 Update API（本文） Spring Boot REST API 最佳实践 - 第三章：实现 FindById 和 DeleteById API Spring Boot REST API 最佳实践 - 第四章：REST API 的异常处理 本文是 Spring Boot REST API 最佳实践 - 第一章 的续章。因此，如果你还没有阅读，请先阅读第一章。我们将在第一章中实现的代码基础上构建 API。 你可以在此 GitHub 仓库中找到本教程中的示例代码。 实现 POST /api/bookmarks API 端点 我们可以考虑按如下方式实现 POST /api/bookmarks API 端点： package com.sivalabs.bookmarks.api.controllers; import com. https://springdoc.cn/spring-boot-rest-api-best-practices-part-1/ Tue, 12 Sep 2023 08:57:26 +0800 https://springdoc.cn/spring-boot-rest-api-best-practices-part-1/ 在本章节教程中，我将介绍我们在实现 REST API 时应遵循的一些最佳实践，和开发人员常犯的一些错误以及如何避免这些错误。 Spring Boot REST API 最佳实践 - 第一章：实现 Get Collection API（本文） Spring Boot REST API 最佳实践 - 第二章：实现 Create 和 Update API Spring Boot REST API 最佳实践 - 第三章：实现 FindById 和 DeleteById API Spring Boot REST API 最佳实践 - 第四章：REST API 的异常处理 在第一章中，我们将实现第一个 API 端点，即获取资源列表。我们将了解开发人员常犯的一些错误以及如何避免这些错误。 创建 Spring Boot 应用 首先，访问 https://start.springboot.io，选择 Spring Web、Validation、Spring Data JPA、PostgreSQL Driver、Flyway Migration 和 Testcontainers starter，创建一个 Spring Boot 应用程序。 我们的示例应用及其简单，但却是按真实应用程序中遵循的相同实践进行操作。 本教程中的示例代码，可以在 GitHub 中找到。 https://springdoc.cn/spring-data-redis-listening-for-key-expiration/ Tue, 12 Sep 2023 08:30:46 +0800 https://springdoc.cn/spring-data-redis-listening-for-key-expiration/ 在 Redis 数据库中，可以通过 EXPIRE、EXPIREAT、EXPIRETIME 命令来设置 Key 的有效时间，当一个 Key 过期后会自动从数据库中删除，释放空间。 得益于于这个特性，我们可以很轻松地实现诸多类似于 “Session” 管理、数据缓存等功能。它们都有一个共同点就是，数据不会永久保存！ 在有些场景中，我们可能希望在某些 Key 过期的时候获取到通知，进行一些业务处理。或者是干脆用于 “定时通知/任务” 功能，例如：下单 30 分钟后未支付，则取消订单。那么可以在用户下单的时候使用订单号作为 key 设置到 Redis 数据库中，并且设置过期时间为 30 分钟。当超时后，我们可以在 “key 过期通知” 中获取到 key 也就是订单号，判断用户是否已经支付从而是否取消订单。 注意： Redis 的 Key 过期通知功能本质上是通过 发布/订阅 功能实现的。也就是说，它不能保证通知消息的交付，当 Key 过期时如果服务器停机、重启中则该通知消息会永久丢失。 本文将会带你学习如何在 Spring Boot 应用中使用 Spring Data Redis 监听 Redis Key 过期事件。 本文所使用的软件版本： Spring Boot：3.1.3 Redis：7.0.5 整合 Spring Data Redis 得益于 Spring Boot 对 Redis 开箱即用的支持，只需要 2 步，就可以快速地在 Spring Boot 中整合、使用 Redis。 https://springdoc.cn/spring-boot-singleton-vs-beans/ Mon, 11 Sep 2023 14:27:20 +0800 https://springdoc.cn/spring-boot-singleton-vs-beans/ 1、概览 单例对象经常被开发人员使用，因为应用程序中的许多对象都需要重复使用一个单例。在 Spring 中，我们可以通过 使用 Spring 的单例 Bean 或自己实现单例设计模式 来创建单例对象。 在本教程中，我们将首先了解单例设计模式及其线程安全的实现。然后，我们将了解 Spring 中的 Singleton Bean Scope，并将 singleton Bean 与使用单例设计模式创建的对象进行比较。 最后，我们将介绍一些可行的最佳实践。 本文中的 “Singleton Bean”，即“单例 bean”。 2、单例设计模式 单例是 “GoF” （si人帮？）于 1994 年发布的最简单的设计模式之一。它被归类于创建模式，因为单例提供了一种只创建一个实例的方法。 2.1、模式定义 单例模式是指由一个类负责创建对象，并确保只创建一个实例。我们经常使用单例来共享状态或减少创建多个对象的成本。 单例模式实现可以确保只创建一个实例： 通过实现单个私有构造函数来隐藏所有构造函数。 仅在实例不存在时创建实例，并将其存储在私有静态变量中。 使用公共静态 getter 方法访问该单例。 让我们看看几个使用单例对象的类的示例： 在上面的类图中，我们可以看到多个服务如何使用只创建一次的同一个单例。 2.2、懒加载 单例模式实现通常使用懒加载来延迟实例创建（也称为“懒汉式”），直到第一次实际需要时才创建。为了确保延迟实例化，我们可以在首次调用静态 getter 方法时创建实例： public final class ThreadSafeSingleInstance { private static volatile ThreadSafeSingleInstance instance = null; private ThreadSafeSingleInstance() {} public static ThreadSafeSingleInstance getInstance() { if (instance == null) { synchronized(ThreadSafeSingleInstance.class) { if (instance == null) { instance = new ThreadSafeSingleInstance(); } } } return instance; } // 标准的 getter 方法 } 在多线程应用中，延迟加载可能会导致并发问题。因此，我们还应用了双重检查锁，以防止不同线程创建多个实例。 https://springdoc.cn/spring-resttemplate-exchange-postforentity-execute/ Mon, 11 Sep 2023 13:32:16 +0800 https://springdoc.cn/spring-resttemplate-exchange-postforentity-execute/ 1、简介 在本教程中，我们将了解 RestTemplate 类中 exchange()、postForEntity() 和 execute() 方法之间的区别。 2、RestTemplate 是啥？ RestTemplate 是 Spring 框架 中的一个工具类，它能让发送 HTTP 消息和处理响应变得简单。RestTemplate 类提供了许多功能，非常适合编写简单的 HTTP 客户端： 支持所有标准 HTTP 方法（GET、POST 等）。 能够处理所有标准 MIME Type（JSON、XML、表单等）。 高级 API 允许我们使用 Java 代码进行配置，并避免复杂的序列化问题。 可使用 ClientHttpRequestInitializer 和 ClientHttpRequestInterceptor 接口进行自定义。 2.1、废弃警告 从 Spring 5 开始，RestTemplate 类逐渐被弃用。虽然它在 Spring 6 中仍然存在，但维护者已经明确表示，该类今后不会再有任何改进，只接受较小的错误和安全修复。 因此，我们鼓励开发人员使用 WebClient。该类拥有更现代的 API，支持同步、异步和 stream 场景。 3、RestTemplate 基本用法 RestTemplate 通过提供具有相应名称的 public 方法，让使用标准 HTTP 方法变得简单。 例如，要发送 GET 请求，我们可以使用带有 getFor 前缀的多种重载方法之一。其他 HTTP 方法也类似，包括 POST、PUT、DELETE、HEAD 和 PATCH。 所有这些方法的结构几乎相同。它们基本上只需要有关的 URL 信息，以及请求和响应体的表示方法。header 等信息会自动生成。 https://springdoc.cn/spring-boot-3-migration/ Mon, 11 Sep 2023 12:22:17 +0800 https://springdoc.cn/spring-boot-3-migration/ 1、概览 在本教程中，我们将学习如何将 Spring Boot 应用迁移到 3.0 版本。当前所使用的 Spring Boot 版本是 2.7，并且 Java 版本是 17。 2、核心的变化 Spring Boot 3.0 是该框架的一个重要里程碑，对其核心组件进行了多项重要修改。 2.1、配置属性 部分属性的修改： spring.redis 已移至 spring.data.redis。 spring.data.cassandra 已移至 spring.cassandra。 移除了spring.jpa.hibernate.use-new-id-generator。 server.max.http.header.size 已移至 server.max-http-request-header-size。 移除了对 spring.security.saml2.relyingparty.registration.{id}.identity-provider 的支持。 要识别这些属性，我们可以在 pom.xml 中添加 spring-boot-properties-migrator： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-properties-migrator</artifactId> <scope>runtime</scope> </dependency> 最新版本的 spring-boot-properties-migrator 可从 Maven Central 获取。 该依赖会在启动时生成并打印一份报告，列出已废弃的属性名称，并在运行时临时迁移这些属性。 2.2、Jakarta EE 10 新版 Jakarta EE 10 对 Spring Boot 3 的相关依赖进行了更新： Servlet 规范更新至 6.0。 JPA 规范更新至 3.1。 因此，如果我们未通过 spring-boot-starter 来自动管理这些依赖的版本，我们就应该手动更新它们。 https://springdoc.cn/spring-boot-flyway-database-migration-tutorial/ Mon, 11 Sep 2023 10:44:46 +0800 https://springdoc.cn/spring-boot-flyway-database-migration-tutorial/ 在之前的 Spring Boot JdbcTemplate 教程 中，我们见识了如何使用 schema.sql 和 data.sql 脚本初始化数据库。这对于演示项目可能有用，但对于实际应用，我们应该使用数据库迁移工具。 Flyway 是最流行的基于 Java 的数据库迁移工具。可以将 Flyway 作为独立库，或使用 flyway-maven-plugin 或使用 Flyway Gradle 插件进行数据库迁移。 Spring Boot 提供了开箱即用的支持，用于 Flyway 数据库迁移。让我们看看如何创建一个使用 Spring Data JPA 与 PostgreSQL 数据库交互，并使用 Flyway 实现数据库迁移的 Spring Boot 应用。 首先，访问 https://start.springboot.io/，选择 Spring Web、Spring Data JPA、PostgreSQL Driver、Flyway Migration 和 Testcontainers starter，创建 Spring Boot 应用程序。 创建 Flyway 迁移脚本 Flyway 遵循 V<VERSION>__<DESCRIPTION>.sql 命名约定来命名其版本化的迁移脚本。让我们在 src/main/resources/db/migration 文件夹下添加以下两个迁移脚本。 V1__create_tables.sql： create table bookmarks ( id bigserial not null, title varchar not null, url varchar not null, created_at timestamp, primary key (id) ); V2__create_bookmarks_indexes. https://springdoc.cn/spring-boot-war-packaged/ Mon, 11 Sep 2023 08:59:46 +0800 https://springdoc.cn/spring-boot-war-packaged/ Spring Boot 最具特色的功能就是使用嵌入式服务器，可以把应用构建为一个独立、可执行的 jar，这极大地方便了部署。但是仍有人希望把应用打包为 WAR 包，部署在外部的 Servlet 容器（Tomcat、Jetty 等）中运行。 本文将会指导你如何更改 Spring Boot 的打包方式为 War，并且部署到外部服务器中（Servlet 3.x +）。 Spring Boot 打包为 War 包的步骤 1、修改打包方式 <packaging>war</packaging> 修改 packaging 节点值为 war。Maven 工程默认打包方式为 jar，如果你的 pom.xml 中没有 packaging 节点，则需要手动设置。 2、修改 Servlet 容器的 scope <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> <scope>provided</scope> </dependency> 由于我们会使用外部的 Tomcat，所以需要主动把嵌入式容器 spring-boot-starter-tomcat 依赖的 scope 声明为 provided，表示该依赖只用于编译、测试。 3、修改启动类，继承 SpringBootServletInitializer package cn.springdoc.demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.boot.web.servlet.support.SpringBootServletInitializer; @SpringBootApplication public class DemoApplication extends SpringBootServletInitializer{ public static void main(String[] args) { SpringApplication. https://springdoc.cn/spring-data-redis-ttl/ Sun, 10 Sep 2023 11:40:42 +0800 https://springdoc.cn/spring-data-redis-ttl/ 1、简介 在本教程中，我们将学习如何在 Spring Data Redis 中配置 key 的过期时间。 2、项目设置 假设我们有一个整合了 spring data redis 的 spring boot 项目，我们打算使用 redis 来管理用户的会话（Session）。 2.1、依赖 首先，在 pom.xml 中添加以下依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>3.0.4</version> </dependency> spring-boot-starter-data-redis 将传递依赖 spring-data-redis 和 lettuce-core。 2.2、Redis 配置 其次，添加 RedisTemplate 配置： @Configuration public class RedisConfiguration { @Bean public RedisTemplate<String, Session> getRedisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate<String, Session> redisTemplate = new RedisTemplate<>(); redisTemplate.setConnectionFactory(redisConnectionFactory); return redisTemplate; } } 2.3、Model 第三，创建 Session model： @RedisHash public class Session { @Id private String id; private Long expirationInSeconds; } 2. https://springdoc.cn/spring-cloud-feignclient-url/ Sun, 10 Sep 2023 11:04:28 +0800 https://springdoc.cn/spring-cloud-feignclient-url/ 1、简介 在本文中，我们将学习如何给 Feign Client 接口设置目标 URL。 2、概览 为了快速入门，我们将使用 JSONPlaceholder 网站中 Album（相册）、Post（帖子）和 Todo 对象的模拟响应。 Album 类如下： public class Album { private Integer id; private Integer userId; private String title; // get、set 方法省略 } Post 类如下： public class Post { private Integer id; private Integer userId; private String title; private String body; //get、set 方法省略 } Todo 类如下： public class Todo { private Integer id; private Integer userId; private String title; private Boolean completed; // get、set 方法省略 } 3、在注解中添 Base URL 我们可以在客户端接口的 @FeignClient 注解中的 url 属性中设置 base URL。然后，我们用相关 HTTP 动词注解方法，并添加所需的端点： https://springdoc.cn/all-together-now-spring-boot-3-2-graalvm-native-images-java-21-and-virtual/ Sat, 09 Sep 2023 18:06:13 +0800 https://springdoc.cn/all-together-now-spring-boot-3-2-graalvm-native-images-java-21-and-virtual/ 酝酿已久，我们终于可以创建使用 Spring Boot（3.2）和 Java 21 虚拟线程（Project Loom）的 GraalVM 原生镜像了！ 这一切有什么意义呢？Project Loom 和 GraalVM 原生镜像各自都具有引人注目的运行时特性。我已经等了很久，终于等到了它们的融合！让我们依次唠唠。 GraalVM 原生镜像 GraalVM 是一个 OpenJDK 发行版，提供了一些额外的实用工具，其中包括一个名为 native-image 的工具，它可以对你的代码进行提前编译（AOT）。我们在这里不会详细介绍所有的实用功能，基本上它会对你的代码进行优化，去除你不需要的部分，然后将剩余的代码编译成针对特定操作系统和架构的原生代码，运行速度非常快。结果令人惊叹，类似于编译 C 或 Go 程序所得到的结果。生成的可执行文件在启动时几乎没有延迟，并且在运行时占用的内存要少得多。想象一下，能够部署现有的 Spring Boot 应用程序，并且它只占用几十兆字节的内存，并在几百毫秒内启动。现在，这是可能的。只需运行 ./gradlew nativeCompile 或 ./mvnw -Pnative native:compile，即可。自 2022 年 11 月 Spring Boot 3.0 发布以来，Spring Boot 已经支持在生产环境中使用 GraalVM 原生镜像。 Project Loom Project Loom 为 JVM 引入了透明的 Fiber（纤程，也成为协程、虚拟线程）。就目前而言，在 Java 20 或更早的版本中，IO 是阻塞的。调用 InputStream#read() 可能需要等待下一个字节的到达。在 java.io.File IO中，很少会有太多延迟。然而，在网络中，你真的无法确定。客户端可能会断开连接。客户端可能会经过一个隧道。同样，很难说。在此期间，程序流程被阻塞在执行线程上。在下面的代码片段中，我们无法知道何时会看到打印出来的单词 after。可能是从现在开始的纳秒级时间，也可能是从现在开始的一周后。它是阻塞的。 InputStream in = ... System.out.println("before"); int next = in. https://springdoc.cn/spring-boot-custom-swagger-url/ Sat, 09 Sep 2023 17:49:51 +0800 https://springdoc.cn/spring-boot-custom-swagger-url/ 1、概览 Springfox 和 SpringDoc 这两个工具简化了 Swagger API 文档的生成和维护。 在本教程中，我们将了解如何在 Spring Boot 应用中更改 Swagger-UI URL 前缀。 2、使用 Springdoc 时更改 Swagger UI URL 前缀 首先，我们可以看看 如何使用 OpenAPI 3.0 生成 REST API 文档。 根据上述教程，我们需要添加如下 SpringDoc 的依赖： <dependency> <groupId>org.springdoc</groupId> <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId> <version>2.0.2</version> </dependency> swagger-ui 的默认 URL 是 http://localhost:8080/swagger-ui.html。 比方说，我们要增加 /myproject 前缀，接下来让我们看看自定义 swagger-UI URL 的两种方法。 2.1、application.properties 我们可以在 application.properties 文件中添加以下属性来修改 swagger-UI URL： springdoc.swagger-ui.disable-swagger-default-url=true springdoc.swagger-ui.path=/myproject 2.2、配置类 我们也可以通过配置类来实现： @Component public class SwaggerConfiguration implements ApplicationListener<ApplicationPreparedEvent> { @Override public void onApplicationEvent(final ApplicationPreparedEvent event) { ConfigurableEnvironment environment = event. https://springdoc.cn/swagger-set-example-description/ Sat, 09 Sep 2023 17:47:27 +0800 https://springdoc.cn/swagger-set-example-description/ 1、概览 在本教程中，我们将演示如何使用 Swagger 注解使我们的文档更具描述性。我们会学习如何为 API 的不同部分（如方法、参数、响应等）添加描述，以及如何添加请求/响应示例。 2、项目设置 我们将创建一个简单的 Product API，提供创建和获取 product 的方法。 要从头开始创建 REST API，我们可以按照 Spring 文档中的教程 使用 Spring Boot 创建 RESTful Web 服务。 下一步是为项目设置依赖和配置。我们可以按照 本文 中的步骤使用 Spring REST API 设置 Swagger 2 3、创建 API 创建 Product API 并检查生成的文档。 3.1、Model 定义 Product 类： public class Product implements Serializable { private long id; private String name; private String price; // 省略 get/set 构造函数 } 3.2、Controller 定义两个 API 方法： @RestController @Tag(name = "Products API") public class ProductController { @PostMapping("/products") public ResponseEntity<Void> createProduct(@RequestBody Product product) { //creation logic return new ResponseEntity<>(HttpStatus. https://springdoc.cn/spring-rest-docs-vs-openapi/ Sat, 09 Sep 2023 14:03:56 +0800 https://springdoc.cn/spring-rest-docs-vs-openapi/ 1、概览 Spring REST Docs 和 OpenAPI 3.0 是为 REST API 创建 API 文档的两种方法。 在本教程中，我们将探讨它们的相对优缺点。 2、前世今生 Spring REST Docs 是由 Spring 社区开发的一个框架，用于 为RESTful API 创建准确的文档。它采用了测试驱动的方法，文档可用 Spring MVC tests、Spring Webflux 的 WebTestClient 或 REST-Assured 形式编写。 运行测试的结果会生成 AsciiDoc 文件，可以使用 Asciidoctor 将它们组合在一起，生成描述 API 的 HTML 页面。由于它遵循 TDD 方法，Spring REST Docs 自动带来了许多优势，例如减少代码错误、减少重复工作和更快的反馈周期等。 而，OpenAPI 是一种诞生于 Swagger 2.0 的规范。截至本文撰写时，其最新版本为 3.0，并有许多已知的 实现。 与其他规范一样，OpenAPI 也为其实现制定了一些基本规则。简而言之，所有 OpenAPI 实现都应该以 JSON 或 YAML 格式的 JSON 对象生成文档。 还有 许多工具 可以接收 JSON/YAML，并输出 UI 界面来可视化和导航 API。这在验收测试时非常有用。在这里的代码示例中，我们将使用 Springdoc - 一个用于 OpenAPI 3 和 Spring Boot 的框架。 https://springdoc.cn/spring-kafka/ Sat, 09 Sep 2023 12:37:39 +0800 https://springdoc.cn/spring-kafka/ 1、概览 Apache Kafka 是一个分布式且容错的流处理系统。 在本教程中，我们将介绍 Spring 对 Kafka 的支持以及它在原生 Kafka Java 客户端 API 之上提供的抽象层。 Spring Kafka 通过 KafkaTemplate 和使用 @KafkaListener 注解的消息驱动的POJO，提供了简单且典型的 Spring template 编程模型。 2、安装和设置 要下载和安装 Kafka，请参阅 此处 的官方指南。 我们需要在 pom.xml 中添加 spring-kafka 依赖： <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>3.0.0</version> </dependency> 然后按如下方法配置 spring-boot-maven-plugin： <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <mainClass>com.baeldung.spring.kafka.KafkaApplication</mainClass> </configuration> </plugin> 我们的示例应用程序是 Spring Boot。 本文假定服务器使用默认配置启动，并且没有更改服务端口。 3、配置 Topic 之前，我们使用命令行工具在 Kafka 中创建主题： $ bin/kafka-topics.sh --create \ --zookeeper localhost:2181 \ --replication-factor 1 --partitions 1 \ --topic mytopic 但随着 Kafka 引入 AdminClient，我们现在可以以编程式创建 topic。 https://springdoc.cn/spring-boot-aws-lambda/ Sat, 09 Sep 2023 11:36:56 +0800 https://springdoc.cn/spring-boot-aws-lambda/ 1、概览 在本教程中，我们将探讨如何使用 Serverless Application Model (SAM) 框架将 Spring Boot 应用程序部署到 AWS Lambda。 这种方法有助于将现有的 API 服务器迁移到 serverless 上。 通过这种方法，我们可以利用 AWS Lambda 的可扩展性和按执行付费的定价模式，高效、经济地运行我们的应用程序。 2、理解 Lamdba AWS Lambda 是亚马逊网络服务（AWS）提供的 serverless 计算服务。它允许我们在无需配置或管理服务器的情况下运行代码。 Lambda 函数与传统服务器的主要区别之一是，Lambda 函数由事件驱动，生命周期很短。 Lambda 函数不像服务器那样持续运行，而是只在响应特定事件时才运行，例如 API 请求、队列中的消息或上传到 S3 的文件。 我们应该注意到，lambda 在处理第一个请求时需要一定的时间来启动。这就是所谓的 “冷启动”。 如果下一个请求在短时间内出现，可以使用相同的 lambda 运行时，这被称为 “热启动”。如果同时出现多个请求，则会启动多个 Lambda 运行时。 与 Lambda 理想的毫秒级启动时间相比，Spring Boot 的启动时间相对较长，因此我们会讨论这对性能的影响。 3、项目设置 我们通过修改 pom.xml 和添加一些配置来迁移现有的 Spring Boot 项目。 Spring Boot 支持的版本有 2.2.x、2.3.x、2.4.x、2.5.x、2.6.x 和 2.7.x。 3.1、Spring Boot API 示例 我们的应用程序由一个简单的 API 组成，它可以处理对 api/v1/users 端点的任何 GET 请求： https://springdoc.cn/spring-boot-3-url-matching/ Sat, 09 Sep 2023 10:46:46 +0800 https://springdoc.cn/spring-boot-3-url-matching/ 1、概览 在本教程中，我们将学习 Spring Boot 3（Spring 6）在 URL 匹配方面引入的变化。 Spring Boot 使用 DispatcherServlet 处理 URL 映射，它会根据 URL 将请求转发到相应的 controller。DispatcherServlet 使用一组称为映射（mapping）的规则来确定使用哪个 controller 来处理请求。 2、Spring MVC 和 Webflux URL 匹配的更改 Spring Boot 3 对“尾斜线匹配”配置选项进行了重大修改。该选项决定是否将带尾斜线的 URL 与不带尾斜线的 URL 作相同处理。以前版本的 Spring Boot 默认将此选项设置为 true。这意味着 controller 默认会同时匹配 GET /some/greeting 和 GET /some/greeting/： @RestController public class GreetingsController { @GetMapping("/some/greeting") public String greeting { return "Hello"; } } 如上，如果我们尝试访问带有尾斜线的 URL，就会收到 404 错误。 让我们来探讨一下如何适应这种变化。 3、添加额外的路由 要处理这种问题，可以额外添加一个专门处理带尾斜线的路由： @RestController public class GreetingsController { @GetMapping("/some/greeting") public String greeting { return "Hello"; } @GetMapping("/some/greeting/") public String greeting { return "Hello"; } } 下面是一个使用 Webflux 的响应式 @RestController： https://springdoc.cn/spring-boot-resilience4j/ Fri, 08 Sep 2023 14:14:53 +0800 https://springdoc.cn/spring-boot-resilience4j/ 1、概览 Resilience4j 是一个轻量级的容错库，提供了诸如熔断、重试、限流、超时、隔板等功能，可以帮助应用程序在面对故障和不稳定条件时保持可用性和可靠性。 在本教程中，我们将学习如何在 Spring Boot 应用程序中使用 Resilience4j。 2、项目设置 2.1、Maven 依赖 首先，我们需要添加 spring-boot-starter-web starter 来创建一个简单的 web 应用： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> 接下来，我们需要 resilience4j-spring-boot2 和 spring-boot-starter-aop 依赖，以便在 Spring Boot 中通过注解使用 Resilience-4j 库的功能： <dependency> <groupId>io.github.resilience4j</groupId> <artifactId>resilience4j-spring-boot2</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 此外，我们还需要添加 spring-boot-starter-actuator 依赖，以便通过暴露一组端点来监控应用的当前状态： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> 最后，还要添加 wiremock-jre8 依赖，用于帮助我们使用 mock HTTP server 测试 REST API： <dependency> <groupId>com.github.tomakehurst</groupId> <artifactId>wiremock-jre8</artifactId> <scope>test</scope> </dependency> 2.2、RestController 和外部 API 调用 在使用 Resilience4j 库的不同功能时，我们的 web 应用需要与外部 API 进行交互。因此，我们需要添加一个 RestTemplate bean，用于 API 调用： https://springdoc.cn/spring-boot-load-multiple-yaml-configuration-files/ Fri, 08 Sep 2023 13:41:06 +0800 https://springdoc.cn/spring-boot-load-multiple-yaml-configuration-files/ 1、概览 在设计 Spring Boot 应用程序时，我们通常希望使用外部配置来定义 application properties。这样，我们就可以在不同的环境中使用相同的代码。在某些情况下，即使是同一个环境，我们可能希望将属性定义在多个 YAML 配置文件中。 在本教程中，我们将学习在 Spring Boot 应用中加载多个 YAML 配置文件的两种方法。 2、使用 Spring Profiles 在应用程序中包含多个 YAML 配置文件的一种方法是使用 Spring profiles。 这种方法利用了 “Spring 自动加载与 profiles 相关联的 YAML 配置文件” 的功能。 接下来，让我们以两个 .yml 文件为例进行说明。 2.1、YAML 配置 我们的第一个文件列出了 student 列表。我们将其命名为 application-students.yml，并将其放在 ./src/main/resources 目录中： students: - Jane - Michael 我们将第二个文件命名为 application-teachers.yml，并放置在相同的 ./src/main/resources 目录中： teachers: - Margo - Javier 2.2. Application 现在，让我们来设置我们的示例应用。我们将在应用中使用 CommandLineRunner 来查看属性加载情况： @SpringBootApplication public class MultipleYamlApplication implements CommandLineRunner { @Autowired private MultipleYamlConfiguration config; public static void main(String[] args) { SpringApplication springApp = new SpringApplication(MultipleYamlApplication. https://springdoc.cn/spring-boot-caffeine-spring-get-all-keys/ Fri, 08 Sep 2023 13:13:02 +0800 https://springdoc.cn/spring-boot-caffeine-spring-get-all-keys/ 1、概览 在本文中，我们将学习如何在使用 Spring Cache 时获取 Caffeine 缓存中的所有缓存 KEY。 2、Spring Cache 缓存（Cache）是 Spring Framework 不可分割的一部分。从 3.1 版本开始，它就是 Spring 生态系统的一部分。因此，它拥有一套定义明确、久经考验的接口。 让我们来看看其中两个主要接口： CacheManager 和 Cache： interface CacheManager { Cache getCache(String name); Collection<String> getCacheNames(); } public interface Cache { String getName(); Object getNativeCache(); ValueWrapper get(Object key); <T> T get(Object key, @Nullable Class<T> type); <T> T get(Object key, Callable<T> valueLoader); void put(Object key, @Nullable Object value); ValueWrapper putIfAbsent(Object key, @Nullable Object value); void evict(Object key); void clear(); } 我们可以看到，CacheManager 是应用程序中可用缓存的注册中心。而 Cache 对象则是缓存内的一组键值对。 https://springdoc.cn/spring-boot-junit-5-testing-active-profile/ Fri, 08 Sep 2023 11:15:21 +0800 https://springdoc.cn/spring-boot-junit-5-testing-active-profile/ 1、概览 我们经常需要为开发和部署过程中的不同阶段创建不同的配置。在 Spring Boot 应用中，我们可以为每个不同的阶段定义一个 Spring Profile 并为其创建专门的测试。 在本教程中，我们将介绍如何使用 JUnit 5 基于激活的 Spring Profile 来进行测试。 2、项目设置 首先，在我们的项目中添加 spring-boot-starter-web 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> 现在，让我们创建一个简单的 Spring Boot 应用： @SpringBootApplication public class ActiveProfileApplication { public static void main (String [] args){ SpringApplication.run(Application.class); } } 最后，创建 application.yaml 配置文件。 3、Spring Profile Spring Profile 提供了一种方法，通过对每个环境的特定配置进行分组，来定义和管理不同的环境。 通过激活特定的 Profile，我们可以在不同的配置之间轻松切换。 3.1、在 Properties 中激活 Profile 我们可以在 application.yaml 文件中指定要激活的 profile： spring: profiles: active: dev 现在 Spring 将检索激活的 profile 的所有属性，并将所有专用 Bean 加载到 application context 中。 https://springdoc.cn/spring-file-upload-json/ Fri, 08 Sep 2023 09:13:02 +0800 https://springdoc.cn/spring-file-upload-json/ 一般我们会使用 multipart/form-data 请求来上传文件。multipart/form-data 请求可以有多个子请求体，每个子请求体都可以有自己的 header 和 body。 本文将带你了解如何在 Spring Boot 应用中使用 multipart/form-data 请求同时上传文件、JSON、表单数据。 服务端 Controller 定义文件上传 controller。 package cn.springdoc.demo.controller; import java.io.IOException; import java.io.InputStream; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.http.MediaType; import org.springframework.util.StreamUtils; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestPart; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.multipart.MultipartFile; import cn.springdoc.demo.model.Meta; @RestController @RequestMapping("/upload") public class UploadController { private static final Logger log = LoggerFactory.getLogger(UploadController.class); /** * 文件上传 * @param file * @param response * @return * @throws IOException */ @PostMapping(consumes = MediaType. https://springdoc.cn/thymeleaf-text-vs-value/ Thu, 07 Sep 2023 14:03:26 +0800 https://springdoc.cn/thymeleaf-text-vs-value/ 1、概览 Thymeleaf 是一种流行的 Java 模板引擎，它允许我们创建动态网页。它提供了多种属性，用于将数据从模型绑定到视图。 在本教程中，我们将了解 Thymeleaf 中 th:text 和 th:value 属性之间的主要区别。 2、th:text 属性 Thymeleaf 中的 th:text 属性用于设置元素的文本内容。 它还取代了标准的 HTML text 属性。因此，我们可以把它放在任何支持文本内容的 HTML 元素中，如标题、段落、标签等。 我们还可以使用该属性来显示动态文本内容，例如网页上的标题。 假设我们想在 HTML 页面上显示 controller 提供的 title 属性。 首先，让我们创建一个 controller 类和一个指定模型属性的方法： @GetMapping public String show(Model model) { model.addAttribute("title", "Baeldung"); return "attributes/index"; } 接下来，我们将在标题元素中显示值： <h1 th:text="${title}"/> 在这里，Thymeleaf 会计算表达式 ${title}，并将该值插入标题元素。 我们将得到的 HTML 如下： <h1>Baeldung</h1> 此外，与标准 HTML text 属性不同，th:text 属性支持表达式。除了变量，这些表达式还可能包括运算符和函数。 例如，让我们在没有提供 title 属性的情况下指定默认值： <h1 th:text="${title} ?: 'Default title'"/> 3、th:value 属性 另一方面，th:value 属性用于设置通常需要用户输入的元素的值。输入框、复选框、单选按钮和下拉按钮等元素都属于此类。 https://springdoc.cn/spring-boot-chatgpt-api-openai/ Thu, 07 Sep 2023 13:02:47 +0800 https://springdoc.cn/spring-boot-chatgpt-api-openai/ 1、概览 在本教程中，我们将学习如何在 Spring Boot 中调用 OpenAI ChatGPT API。我们将创建一个 Spring Boot 应用程序，通过调用 OpenAI ChatGPT API 来生成对提示的回复。 2、OpenAI ChatGPT API 在开始本教程之前，让我们先了解一下本教程中将使用的 OpenAI ChatGPT API。我们将调用 create chat completion API 来生成对提示的回复。 2.1、API 参数和认证 让我们来看看 API 强制的请求参数： model - 是我们将向其发送请求的模型版本。该模型有几个版本。我们将使用 gpt-3.5-turbo 模型，它是 该模型的最新公开版本。 messages - 发送给模型的提示。每条 message 都需要两个字段：role 和 content。role 字段指定信息的发送者。在请求中是 user，在回复中是 assistant。content 字段是实际的消息。 API 调用需要认证，我们需要生成一个 OpenAI API key。在调用 API 时在 Authorization 头中设置该 key。 cURL 格式的请求示例如下： $ curl https://api.openai.com/v1/chat/completions \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -d '{ "model": "gpt-3. https://springdoc.cn/spring-6-virtual-threads/ Thu, 07 Sep 2023 12:28:28 +0800 https://springdoc.cn/spring-6-virtual-threads/ 1、简介 在这个简短的教程中，我们将了解如何在 Spring Boot 中使用虚拟线程（Virtual Threads）。 虚拟线程是 Java 19 的 预览特性，这意味着它们将在未来 12 个月内被纳入 JDK 的正式版本中。虚拟线程最初是由 Loom 项目引入的，在 Spring 6 中，开发人员可以一睹为快了。 首先，我们将了解 “平台线程” 与 “虚拟线程” 的主要区别。接下来，我们将使用虚拟线程从头开始构建一个 Spring-Boot 应用。最后，我们会进行一个测试，测试 web 应用的吞吐量提升了多少。 2、虚拟线程和平台线程 主要区别在于，虚拟线程在运行周期内不依赖操作系统线程：它们与硬件脱钩，因此被称为 “虚拟”。这种解耦是由 JVM 提供的抽象层赋予的。 虚拟线程的运行成本远低于平台线程。它们消耗的内存要少得多。这就是为什么我们可以创建数百万个虚拟线程而不会出现内存不足的问题，而标准平台（或内核）线程只能创建数百个。 从理论上讲，这赋予了开发人员一种超级能力：无需依赖异步代码即可管理高度可扩展的应用程序。 3、在 Spring 6 中使用虚拟线程 从 Spring Framework 6（和 Spring Boot 3）开始，虚拟线程功能正式全面可用，但虚拟线程是 Java 19 的预览特性。这意味着我们需要告诉 JVM 我们想在应用程序中启用虚拟线程。由于我们使用 Maven 构建应用程序，因此要确保在 pom.xml 中包含以下代码： <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>19</source> <target>19</target> <compilerArgs> --enable-preview </compilerArgs> </configuration> </plugin> </plugins> </build> 从 Java 的角度来看，要使用 Apache Tomcat 和虚拟线程，我们需要一个简单的配置类和几个 Bean： https://springdoc.cn/spring-boot-database-transaction-management-tutorial/ Thu, 07 Sep 2023 10:27:52 +0800 https://springdoc.cn/spring-boot-database-transaction-management-tutorial/ 在 Spring 应用中，无论使用 JdbcTemplate 还是 JPA/Hibernate 或 Spring Data JPA，都需要处理数据库事务。 数据库事务是一个事务单元，它要么全部完成，要么都不完成，并使数据库处于一致状态。在实现数据库事务时，需要考虑到 ACID（原子性、一致性、隔离性、持久性）属性。 让我们了解一下如何在 Spring Boot 应用中处理数据库事务。 使用 JDBC 进行事务处理 首先，让我们快速了解一下我们通常是如何在普通 JDBC 中处理数据库事务的。 class UserService { void register(User user) { String sql = "..."; Connection conn = dataSource.getConnection(); // <1> try(conn) { // <6> conn.setAutoCommit(false); // <2> PreparedStatement pstmt = conn.prepareStatement(sql); pstmt.setString(1, user.getEmail()); pstmt.setString(2, user.getPassword()); pstmt.executeUpdate(); // <3> conn.commit(); // <4> } catch(SQLException e) { conn.rollback(); // <5> } } } 在上述代码片段中： https://springdoc.cn/resttemplate-file-upload/ Thu, 07 Sep 2023 09:21:29 +0800 https://springdoc.cn/resttemplate-file-upload/ 在调用第三方Api服务的时候，如果涉及到文件上传，就需要自己通过 Http 客户端发起 Multipart 请求来上传文件。 在 Spring 应用中比较流行的 Http 客户端就是 RestTemplate。本文将会指导你如何用 RestTemplate 发起 Multipart 请求来上传文件。 服务端 在服务端创建一个用于测试的 FileUploadController， 它接受来自客户端的 Multipart 文件请求，并且响应文件的相关信息。 package cn.springdoc.demo.controller; import java.io.IOException; import java.io.InputStream; import java.util.HashMap; import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.http.MediaType; import org.springframework.util.StreamUtils; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestPart; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.multipart.MultipartFile; import jakarta.servlet.http.HttpServletResponse; @RestController @RequestMapping("/upload") public class FileUploadController { private static final Logger log = LoggerFactory.getLogger(FileUploadController.class); /** * 文件上传 * @param file * @param response * @return * @throws IOException */ @PostMapping(consumes = MediaType. https://springdoc.cn/spring-modulith-intro/ Wed, 06 Sep 2023 22:20:26 +0800 https://springdoc.cn/spring-modulith-intro/ 1、简介 模块化单体（Modular Monolith）是一种架构风格，在这种风格中，我们的源代码按照模块的概念进行结构化。对于许多组织来说，模块化单体是一个很好的选择。它有助于保持一定程度的独立性，这有助于我们在需要时过渡到微服务架构。 Spring Modulith 是 Spring 的一个实验项目，可用于模块化单体应用程序。此外，它还支持开发人员构建结构合理、领域一致的 Spring Boot 应用程序。 在本教程中，我们将讨论 Spring Modulith 项目的基础知识，并举例说明如何实际使用它。 2、模块化单体架构 我们有不同的选择来构建应用程序的代码。传统上，我们围绕基础设施设计软件解决方案。但是，当我们围绕业务设计应用程序时，就能更好地理解和维护系统。模块化单体架构就是这样一种设计。 模块化单体架构因其简单性和可维护性而越来越受到架构师和开发人员的青睐。如果我们将领域驱动设计（DDD）应用于现有的单体应用程序，就可以将其重构为模块化单体架构： 我们可以通过确定应用程序的领域和定义有界上下文，将单体的核心拆分成模块。 让我们来看看如何在 Spring Boot 框架内实现模块化单体应用程序。Spring Modulith 包含一系列库，可帮助开发人员构建模块化 Spring Boot 应用程序。 3、Spring Modulith 基础 Spring Modulith 可帮助开发人员使用由领域（domain）驱动的模块，并支持对这种模块化进行验证和文档化。 3.1、Maven 依赖 首先，让我们在 pom.xml 的 <dependencyManagement> 部分导入 spring-modulith-bom 依赖： <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.experimental</groupId> <artifactId>spring-modulith-bom</artifactId> <version>0.5.1</version> <scope>import</scope> <type>pom</type> </dependency> </dependencies> </dependencyManagement> 此外，我们还需要一些 Spring Modulith 核心依赖： <dependency> <groupId>org.springframework.experimental</groupId> <artifactId>spring-modulith-api</artifactId> </dependency> <dependency> <groupId>org.springframework.experimental</groupId> <artifactId>spring-modulith-starter-test</artifactId> <scope>test</scope> </dependency> 3.2、模块 Spring Modulith 的主要概念是模块。模块是将 API 暴露给其他模块的功能单元。此外，它还有一些不允许其他模块访问的内部实现。当我们设计应用程序时，我们会为每个域（domain）考虑一个模块。 https://springdoc.cn/spring-boot-cli-encode-passwords/ Wed, 06 Sep 2023 20:00:32 +0800 https://springdoc.cn/spring-boot-cli-encode-passwords/ 1、概览 Spring Boot CLI 是一个 Spring Boot 工具，用于从命令运行和测试 Spring Boot 应用。该工具提供了一个非常有用的密码编码功能，主要目的是避免暴露明文形式的密码。 在本教程中，我们将深入 Spring Security 的世界，学习如何使用 Spring Boot CLI 对密码进行编码。 2、密码编码 密码编码是一种将密码以二进制格式表示并保存在存储介质上的简单方法。我们可以使用 Spring Security 对密码进行编码，也可以通过 Spring Boot CLI 进行编码。 2.1、Spring Security PasswordEncoder Spring Security 提供了 PasswordEncoder 接口，并且预置了很多实现，如 StandardPasswordEncoder 和 BCryptPasswordEncoder。 此外，Spring Security 建议使用基于强大算法和随机生成盐值的 BCryptPasswordEncoder。在框架的早期版本中，可以使用 MD5PasswordEncoder 或 SHAPasswordEncoder 类，但由于其算法的弱点，它们现在已被弃用，这两个类强制开发者将盐作为构造函数参数传递。而 BCryptPasswordEncoder 将在内部生成随机盐，BCryptPasswordEncoder 生成的字符串大小为 60 个字符。 而 StandardPasswordEncoder 类则基于 SHA-256 算法。 显然，在第三方系统中创建的用户密码必须按照 Spring Security 中选择的编码类型进行编码，这样才能成功进行身份认证。 2.2、Spring Boot CLI Password Encoder Spring Boot CLI 提供了许多命令，其中之一就是 encodepassword。该命令允许对密码进行编码，以便与 Spring Security 配合使用。简单地说，Spring Boot Cli 可以使用这种简单的 encodepassword 命令直接将原始密码转换为加密密码： https://springdoc.cn/spring-self-injection/ Wed, 06 Sep 2023 14:22:28 +0800 https://springdoc.cn/spring-self-injection/ 1、概览 自注入是指 Spring Bean 将自身作为依赖注入。它使用 Spring 容器获取自身的引用，然后使用该引用执行某些操作。 在这个简短的教程中，我们将了解如何在 Spring 中使用自注入。 2、自注入的场景 自注入最常见的用例是在需要将切面应用于自引用的方法或类时，绕过 Spring AOP 的限制 假设我们有一个执行某些业务逻辑的 service 类，需要调用自身的一个方法作为该逻辑的一部分： @Service public class MyService { public void doSomething() { // ... doSomethingElse(); } @Transactional public void doSomethingElse() { // ... } } 不过，当我们运行应用程序时，可能会发现 @Transactional 并未生效。这是因为 doSomething() 方法直接调用了 doSomethingElse()，从而绕过了 Spring 代理。 为了解决这个问题，我们可以使用自注入获取 Spring 代理的引用，然后通过该代理调用方法。 3、使用 @Autowired 自注入 在 Spring 中，我们可以通过在 Bean 的字段、构造器参数或 setter 方法上使用 @Autowired 注解来进行自注入。 下面是一个在字段上使用 @Autowired 的示例： @Component public class MyBean { @Autowired private MyBean self; public void doSomething() { // 在这里使用 self 引用 } } 通过构造器参数自注入。 https://springdoc.cn/spring-boot-h2-jdbcsqlsyntaxerrorexception-expected-identifier/ Wed, 06 Sep 2023 13:47:18 +0800 https://springdoc.cn/spring-boot-h2-jdbcsqlsyntaxerrorexception-expected-identifier/ 1、概览 在 Spring Boot 中使用 h2 作为内存数据库的时候遇到异常：org.h2.jdbc.JdbcSQLSyntaxErrorException: Syntax error in SQL statement expected “identifier”。 本文将会介绍出现 org.h2.jdbc.JdbcSQLSyntaxErrorException 的原因以及解决方案。 2、原因 通常，H2 会抛出 JdbcSQLSyntaxErrorException 来提示 SQL 语句中的语法错误。其中，“expected identifier” 信息表明 SQL 期望一个合适的 标识符，而我们没有给出。 导致这种异常的最常见原因是使用保留关键字作为标识符。 例如，使用关键字 table 来命名特定的 SQL 表就会导致 JdbcSQLSyntaxErrorException。 另一个原因是在 SQL 语句中缺少或错用了关键字。 3、重现异常 作为开发者，我们经常使用 user 一词来表示用户表。不幸的是，它在 H2 中是一个 保留关键字。 为了重现异常，我们将故意使用关键字 user。 因此，首先让我们添加一个基本的 SQL 脚本来初始化 H2 数据库并为其添加数据： INSERT INTO user VALUES (1, 'admin', 'p@ssw@rd'); INSERT INTO user VALUES (2, 'user', 'userpasswd'); 接下来，我们将创建一个实体（Entity）类来映射 user 表： https://springdoc.cn/spring-boot-shared-secret-authentication/ Wed, 06 Sep 2023 12:31:35 +0800 https://springdoc.cn/spring-boot-shared-secret-authentication/ 1、概览 身份认证是微服务安全的基础。我们可以通过各种方式实现身份认证，如使用基于用户的凭证、证书或 token。 在本教程中，我们将学习如何使用 Spring Security 实现服务间的通信认证。 2、自定义身份认证简介 在某些情况下，使用 Oauth2 或存储在数据库中的密码可能并不可行，因为私有微服务不需要基于用户的交互。然而，我们仍然应该保护应用程序免受任何无效请求的影响。 在这种情况下，我们可以设计一种简单的身份认证技术，使用自定义 header。应用程序将根据预先配置的请求头认证请求。 我们还应在应用程序中启用 TLS，以确保 header 在网络传输中的安全。 我们可能还需要确保一些端点不需要进行任何身份认证，例如 health 或 error 端点。 3、示例应用 假如，我们需要用几个 REST API 构建一个微服务。 3.1、Maven 依赖 首先，我们将创建一个 Spring Boot Web 项目，添加 spring-boot-starter-web 和 spring-boot-starter-test 依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> 3.2、实现 REST Controller 我们的应用有两个端点，一个端点可通过 secret header 访问，另一个端点可被网络中的所有用户访问。 首先，在 APIController 中实现 /hello 端点： @GetMapping(path = "/api/hello") public String hello(){ return "hello"; } 然后，我们将在 HealthCheckController 类中实现 /health 端点： https://springdoc.cn/spring-boot-jdbctemplate-tutorial/ Wed, 06 Sep 2023 10:12:35 +0800 https://springdoc.cn/spring-boot-jdbctemplate-tutorial/ Spring Boot 对 JDBC 的支持 Spring 的 JdbcTemplate 在 DataSource 的基础上提供了执行数据库操作的高级抽象。配合 Spring 的声明式事务，能以很简单的方式管理数据库事务，而无需编写模板式的代码。 Spring Boot 通过自动配置机制简化了 DataSource、TransactionManager 等的配置。 让我们看看如何使用 JdbcTemplate 对 PostgreSQL 数据库执行 CRUD 操作。 首先，访问 https://start.springboot.io/，选择 JDBC API、PostgreSQL Driver 和 Testcontainers starter，创建 Spring Boot 应用程序。 假设，我们正在开发一个管理书签（bookmarks）的简单应用。因此，我们将创建包含 id、title、url 和 created_at 列的 bookmarks 表。 初始化数据源 Spring Boot 提供了一种方便的数据库初始化机制。我们可以在 src/main/resources 下创建 schema.sql 和 data.sql 文件，这些文件将在启动应用程序时自动执行。不过，只有在使用 HSQL、H2 等内存数据库时，才会默认启用自动脚本执行功能，否则就会禁用。 我们可以在 src/main/resources/application.properties 文件中添加以下属性来启用脚本初始化。 spring.sql.init.mode=always 现在，让我们创建 src/main/resources/schema.sql 文件，如下所示： create table if not exists bookmarks ( id bigserial not null, title varchar not null, url varchar not null, created_at timestamp, primary key (id) ); 要插入一些示例数据，请创建 src/main/resources/data. https://springdoc.cn/spring-cache-delete-scan/ Wed, 06 Sep 2023 08:44:20 +0800 https://springdoc.cn/spring-cache-delete-scan/ 在 Spring Boot 应用中使用 Spring Cache 管理缓存时，可以通过调用 @CacheEvict(allEntries=true) 注解的方法来批量删除当前缓存（cacheNames） 下的所有缓存项目。如下： package cn.springdoc.demo.cache; import org.springframework.cache.annotation.CacheEvict; import org.springframework.stereotype.Component; @Component public class FooCahe { // 清除 “foo” 命名空间下的所有缓存项目 @CacheEvict(cacheNames = "foo", allEntries = true) public void clear () { } } 如果你的 Spring Cache 使用的缓存实现是 Redis，那么默认情况下它会使用 KEYS [pattern] 指令来获取、删除所有匹配的缓存项目。 测试方法如下： package cn.springdoc.demo; import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import cn.springdoc.demo.cache.FooCahe; @SpringBootTest(classes = SpringdocCacheApplication.class) class SpringdocCacheApplicationTests { static final Logger logger = LoggerFactory. https://springdoc.cn/spring-boot-custom-webflux-exceptions/ Tue, 05 Sep 2023 15:14:19 +0800 https://springdoc.cn/spring-boot-custom-webflux-exceptions/ 1、概览 在本教程中，我们将探索 Spring 框架中不同的错误响应格式。我们还将了解如何使用自定义属性抛出和处理 RFC7807 ProblemDetail，以及如何在 Spring WebFlux 中抛出自定义异常。 2、Spring Boot 3 中的异常响应格式 让我们来了解一下开箱即用的各种错误响应格式。 默认情况下，Spring Framework 提供了实现 ErrorAttributes 接口的 DefaultErrorAttributes 类，用于在出现未处理的错误时生成错误响应。在默认错误的情况下，系统会生成一个 JSON 响应，提供了一些详细的信息： { "timestamp": "2023-04-01T00:00:00.000+00:00", "status": 500, "error": "Internal Server Error", "path": "/api/example" } 虽然该错误响应包含一些关键属性，但可能对排除问题没有帮助。幸运的是，我们可以通过在 Spring WebFlux 应用程序中创建 ErrorAttributes 接口的自定义实现来修改默认行为。 从 Spring Framework 6 ProblemDetail 开始，支持 RFC7807 规范的表示。ProblemDetail 包含一些定义错误细节的标准属性，还提供了扩展细节以进行自定义的选项。支持的属性如下所示： type（string） - 标识问题类型的 URI 参考地址。 title（string） - 问题类型简述。 status（number） - HTTP 状态码。 detail（string） - 应包含异常的详细信息。 instance（string） - 一个 URI 参考地址，用于标识问题的具体原因。例如，它可以指向导致问题的属性。 除了上述标准属性外，ProblemDetail 还包含一个 Map<String, Object>，用于添加自定义参数，以提供有关问题的更详细信息。 https://springdoc.cn/spring-boot-actuator-without-spring-boot/ Tue, 05 Sep 2023 14:40:23 +0800 https://springdoc.cn/spring-boot-actuator-without-spring-boot/ 1、概览 Spring Boot 项目 是 Spring 框架的扩展，它提供的功能有助于创建基于 Spring 的独立应用程序，并支持云原生开发。 有时，我们并不想使用 Spring Boot，例如在将 Spring Framework 整合到 Jakarta EE 应用程序时，但我们仍然希望受益于生产就绪功能，如指标和健康检查，即所谓的 “可观察性”。（可在 “Spring Boot 3 和 Observability（可观察性）” 一文中找到详细信息）。 可观察性功能由 Spring Boot Actuator 提供，它是 Spring Boot 的一个子项目。在本文中，我们将了解如何将 Actuator 整合到非 Spring Boot 的应用程序中。 2、项目配置 如果不使用 Spring Boot，我们就需要处理应用打包和服务器运行时配置的问题，还需要自己将 配置外部化，当然，本文并不会涉及这些内容。由于我们不能直接使用 Spring Boot 的 Starter 依赖（本例中为 spring-boot-starter-actuator），因此我们需要在 application context 中手动添加必要的 Bean。 我们可以手动配置，也可以使用自动配置。因为 Actuator 的配置相当复杂，而且没有任何详细的文档说明，所以我们应该选择自动配置。这是我们需要 Spring Boot 的原因之一，因此我们不能完全排除 Spring Boot。 2.1、添加项目依赖 要集成 Actuator，我们需要 Spring-boot-actuator-autoconfigure 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-actuator-autoconfigure</artifactId> <version>3.0.6</version> </dependency> 这也将通过传递依赖 spring-boot-actuator、spring-boot 和 spring-boot-autoconfigure。 https://springdoc.cn/spring-boot-3-gradle-configure-tasks/ Tue, 05 Sep 2023 12:48:22 +0800 https://springdoc.cn/spring-boot-3-gradle-configure-tasks/ 1、简介 Spring Boot Gradle Plugin 在 Gradle 中提供 Spring Boot 支持。它允许我们打包可执行的 JAR 或 war 文件，运行 Spring Boot 应用程序，并使用 spring-boot-dependencies 提供的依赖管理。Spring Boot 3 Gradle Plugin 需要 Gradle 7.x （7.5 或更高版本）或 8.x，并可与 Gradle 的配置缓存一起使用。 在这个教程中，我们将学习关于 Spring Boot 3 Gradle Plugin Task 配置的内容。Spring Boot 3 Gradle Plugin 提供了几个 Gradle task 可用。我们将使用一个简单的 Spring Boot 应用来演示如何配置一些 task。出于演示的目的，我们不会添加任何 security 配置或数据到我们的 Spring Boot 应用中。话不多说，现在让我们深入详细定义和配置这些 task。 2、配置 bootJar Gradle Task 在 Spring Boot 3 Gradle Plugin中，Gradle task 比以前的版本有所改进。一些常见的 Gradle task 包括 bootJar、bootWar、bootRun 和 bootBuildImage。让我们深入了解 bootJar，看看如何配置 bootJar task。 https://springdoc.cn/spring-boot-properties-canonical-form/ Tue, 05 Sep 2023 12:10:27 +0800 https://springdoc.cn/spring-boot-properties-canonical-form/ 1、概览 在教程中，我们将仔细研究 Spring Boot 中出现的错误：Reason: Canonical names should be kebab-case (’-’ separated), lowercase alpha-numeric characters, and must start with a letter。 首先，我们将阐明 Spring Boot 中出现此错误的主要原因。然后，我们将通过一个实际示例深入探讨如何重现和解决这个问题。 2、问题说明 首先，让我们了解一下错误信息的含义。“Canonical names should be kebab-case” 意思是“规范名称应使用短横线命名法（kebab-case）”。 为确保一致性，@ConfigurationProperties 注解的 prefix 参数中使用的命名约定应遵循短横线命名格式。 例如： @ConfigurationProperties(prefix = "my-example") 3、Maven 依赖 在 pom.xml 中添加必要的依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> <version>3.0.5</version> </dependency> spring-boot-starter 是重现问题的唯一依赖。 4、重现问题 4.1、应用配置 注册所需的组件： @Configuration @ConfigurationProperties(prefix = "customProperties") public class MainConfiguration { String name; // get/set 方法省略 } 然后，我们需要在 application. https://springdoc.cn/spring-cache-redis-json/ Tue, 05 Sep 2023 08:34:05 +0800 https://springdoc.cn/spring-cache-redis-json/ 1、Spring Cache 的简介 Spring Cache 是 Spring 框架提供的一个缓存抽象层，用于简化应用中的缓存操作。它通过在方法执行期间将结果存储在缓存中，以便在相同的输入参数下，下一次调用时可以直接从缓存中获取结果，而不必执行相同的计算或查询操作。Spring Cache 支持多种缓存提供商，如 Ehcache、Redis、Caffeine 等，可以根据需求选择合适的缓存实现。通过使用 Spring Cache，开发人员可以轻松地添加缓存功能，提高应用的性能和响应速度。 Redis 是 Spring Cache 中最常用的缓存实现之一，有以下几个主要原因： 高性能：Redis 是一个基于内存的数据存储系统，具有非常高的读写性能。它将数据存储在内存中，可以快速地读取和写入数据，适合作为缓存存储。 数据结构丰富：Redis 支持多种数据结构，如字符串、哈希、列表、集合和有序集合等，这些数据结构的灵活性可以满足不同场景下的缓存需求。 持久化支持：Redis 提供了持久化机制，可以将数据存储到磁盘上，以防止数据丢失。这对于缓存数据的可靠性和持久性是非常重要的。 分布式支持：Redis 支持分布式部署，可以搭建多个 Redis 节点组成集群，实现数据的分片和负载均衡，提高了系统的扩展性和容错性。 生态系统丰富：Redis 有一个活跃的开源社区，提供了许多与 Spring 集成的库和工具，如 Spring Data Redis、Lettuce 和 Redisson 等，这些工具可以方便地与 Spring Cache 集成，简化了开发和配置的过程。 综上所述，Redis 在性能、数据结构、持久化、分布式支持以及生态系统方面的优势，使其成为 Spring Cache 中最常用的缓存实现之一。 本文将会指导你如何在 Spring Boot 中整合 Spring Cache 和 Redis 来开发缓存应用，并且修改其序列化方式为 JSON。 本文中使用的软件版本： spring boot：3.1.3 redis：7.0.5 2、整合 Spring Cache 你可以点击 start.springboot.io 快速地创建此演示项目。 项目的依赖如下： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> <! https://springdoc.cn/spring-boot-profiles-tutorial/ Mon, 04 Sep 2023 11:06:34 +0800 https://springdoc.cn/spring-boot-profiles-tutorial/ Spring Profiles 简介 通常，软件应用程序会在不同的环境中运行。在开发过程中，它将在 local 环境运行，然后我们可能会将它部署到 QA、Staging、Performance 环境中，最后再部署到 Production 环境中。在不同环境中运行应用程序时，你可能需要用不同的配置属性来配置应用程序。 例如，如果你使用了数据库，那么你可以在开发过程中将数据库连接属性配置为本地运行的数据库。在 QA、Staging、Performance 和 Production 环境中部署时，则需要将数据库属性配置为特定环境的数据库。 Spring 为 application properties 的外部化提供了强大的支持，因此我们可以在不同的环境中运行时配置不同的属性。 为了使其更简单，我们可以使用 Spring Profiles 机制。使用不同的 profile 来配置 application properties，然后根据需要启用所需的 profile。 使用 properties 配置 Profile 假设我们正在构建一个使用 PostgreSQL 数据库的 Spring Boot 应用程序。我们希望在本地运行应用程序，使用在笔记本电脑上运行的 PostgreSQL 数据库。此外，我们还希望将应用程序部署到 QA 和 Production 环境中。 我们可以在默认的 properties 文件 src/main/resources/application.properties 中配置默认属性，如下所示： spring.datasource.url=jdbc:postgresql://localhost:5432/postgres spring.datasource.username=postgres spring.datasource.password=postgres 我们可以在 src/main/resources/application-{profile}.{properties/yml} 文件中配置任何特定 profile 的属性，当你激活该 profile 时，Spring Boot 会自动使用该 profile 的属性。因此，我们可以按照以下方式在 src/main/resources/application-qa.properties 中配置 QA profile 的属性： spring.datasource.url=jdbc:postgresql://postgres_qa:5432/postgres spring. https://springdoc.cn/spring-boot-and-spring-data-jpa/ Mon, 04 Sep 2023 09:04:24 +0800 https://springdoc.cn/spring-boot-and-spring-data-jpa/ Spring Data JPA 是 Spring 框架提供的一个模块，用于简化与关系型数据库的交互和数据访问。它基于JPA（Java Persistence API）标准，并提供了一组易于使用的API和工具，帮助开发人员更轻松地进行数据库操作。通过Spring Data JPA，开发人员可以通过编写简洁的代码来执行常见的 CRUD 操作，同时还支持高级查询、分页、事务管理等功能。它的目标是提供一种更简单、更高效的方式来处理数据库操作，减少开发人员的工作量，并提高应用程序的可维护性和可扩展性。 本文将会指导你如何在 Spring Boot 应用中整合、使用 Spring Data Jpa。 软件版本： Java：17 Spring Boot：3.1.3 MySQL：8.0.27 创建工程 点击 start.springboot.io 快速创建 Spring Boot 整合 Spring Data Jpa 的示例应用。 我们选择了 spring-boot-starter-web、spring-boot-starter-data-jpa、mysql-connector-j 和 spring-boot-starter-test 依赖。 pom.xml 如下： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- JPA --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>com.mysql</groupId> <artifactId>mysql-connector-j</artifactId> <scope>runtime</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> spring-boot-starter-data-jpa 默认使用 Hibernate 作为 JPA 实现。本文使用 MYSQL 数据库进行演示，如果你使用其他数据库需要修改驱动。 https://springdoc.cn/field-injection-is-not-recommended/ Sun, 03 Sep 2023 14:50:41 +0800 https://springdoc.cn/field-injection-is-not-recommended/ 1、概览 当我们在 IDE 中运行代码分析工具时，它可能会对带有 @Autowired 注解的字段发出 “Field injection is not recommended” 的警告。 在本教程中，我们将探讨为什么不推荐字段注入，以及我们可以使用哪些替代方法。 2、依赖注入（DI） 依赖注入是一种设计模式，用于管理对象之间的依赖关系。它通过外部容器提供对象的依赖，使得对象之间的关系更加灵活、可配置和可测试。依赖注入提高了代码的可维护性、可测试性和可扩展性。它是 Spring 框架的核心功能之一。 我们可以通过三种方式注入依赖对象，即： 构造函数注入。 Setter 方法注入。 字段注入。 第三种方法是使用 @Autowired 注解将依赖直接注入类中。虽然这可能是最简单的方法，但它可能会导致一些潜在的问题。 更重要的是，即使是在 Spring 的官方文档 中，也不再介绍字段注入。 3、Null 安全 让我们定义 EmailService 类并使用字段注入 EmailValidator 依赖： @Service public class EmailService { @Autowired private EmailValidator emailValidator; } 现在，让我们添加 process() 方法： public void process(String email) { if(!emailValidator.isValid(email)){ throw new IllegalArgumentException(INVALID_EMAIL); } // ... } 我们可以使用默认构造函数直接创建 EmailService 实例。但只有在提供了 EmailValidator 依赖的情况下，EmailService 才能正常工作。 EmailService emailService = new EmailService(); emailService. https://springdoc.cn/spring-postgresql-message-broker/ Sun, 03 Sep 2023 12:24:40 +0800 https://springdoc.cn/spring-postgresql-message-broker/ 1、简介 在本教程中，我们将介绍如何使用 PostgreSQL 的 LISTEN / NOTIFY 命令来在 Spring Boot 应用中实现简单的 MQ。 2、PostgreSQL 的 LISTEN/NOTIFY 机制简介 简单地说，这些命令允许连接的客户端通过普通的 PostgreSQL 连接交换信息。客户端使用 NOTIFY 命令向 channel 发送通知以及可选的 string payload。 channel 可以是任何有效的 SQL 标识符，其工作原理与传统 MQ 系统中的 topic 类似。这意味着 payload 将发送给该特定 channel 的所有活动的监听器（listener）。如果没有 payload，监听者只会收到一个空通知。 要开始接收通知，客户端需要使用 LISTEN 命令，该命令将 channel 名称作为唯一参数。该命令会立即返回，因此客户端可以使用同一连接继续执行其他任务。 通知机制具有一些重要的特性： channel 名称在数据库中是唯一的。 客户端使用 LISTEN/NOTIFY 时无需特殊授权。 在事务中使用 NOTIFY 时，客户端只有在事务成功完成时才会收到通知。 此外，如果在一个事务中使用相同的 payload 向同一 channel 发送多个 NOTIFY 命令，客户端将只收到一个通知。 3、使用 PostgreSQL 作为 Message Broker 的场景 鉴于 PostgreSQL 通知的特性，我们不禁要问，什么时候使用它而不是 RabbitMQ 或类似的成熟 message broker。这需要权衡利弊。一般来说，选择后者意味着： https://springdoc.cn/java-spring-fix-403-error/ Sun, 03 Sep 2023 11:21:36 +0800 https://springdoc.cn/java-spring-fix-403-error/ 1、概览 在 web 开发过程中，经常会遇到 HTTP 403 forbidden error。 在本教程中，我们将学习如何解决 Spring Boot POST 请求中的 403 错误。我们将首先了解 403 错误的含义，然后探讨在 Spring Boot 应用程序中解决该错误的步骤。 2、403 Error 是什么？ HTTP 403 错误（通常称为 “Forbidden” 错误）是一种状态代码，表示服务器理解了请求，但选择不授权。这通常意味着客户端没有权限访问请求的资源。 需要注意的是，该错误不同于 401 错误，后者表示服务器需要对客户端进行身份认证，但尚未收到有效凭证。 “401” 表示需要认证，“403” 表示认证过了（不需要认证），但是没有权限。 3、导致 403 Error 的原因 在 Spring Boot 应用程序中，有几个因素会触发 403 错误。其中之一就是客户端未能提供身份认证凭据。在这种情况下，服务器因无法认证客户端的权限而拒绝请求，从而导致 403 错误。 另一个可能的原因在于服务器配置（server configuration）。例如，出于安全原因，服务器可能被配置为拒绝来自某些 IP 地址或用户代理（user agent）的请求。如果请求来自这些被阻止的资源，服务器会响应 403 错误。 此外，Spring Security 默认启用跨站请求伪造（CSRF）保护。CSRF 是一种通过欺骗受害者提交恶意请求并利用受害者的凭证代表其执行非预期功能的攻击。如果用于防范此类攻击的 CSRF token 丢失或不正确，服务器也可能会响应 403 错误。 4、项目设置 要了解如何解决 403 错误，让我们创建一个带有 spring-boot-starter-web 和 spring-boot-starter-security 依赖的 Spring Boot 项目： https://springdoc.cn/openfeign-http-patch-request/ Sat, 02 Sep 2023 23:14:59 +0800 https://springdoc.cn/openfeign-http-patch-request/ 1、概览 通过 REST API 更新资源时，可以使用 PATCH 方法。该方法专门用于“更新部分字段”的场景。当需要完全更改现有资源时（全量替换），可以使用 PUT 方法。 在本教程中，我们将学习如何在 OpenFeign 中设置 HTTP PATCH 方法。我们还将演示在 Feign client 测试 PATCH 方法时出现的异常情况，以及解决方案。 2、Spring Boot 中的应用示例 假设我们需要构建一个简单的微服务，调用下游服务进行部分更新。 2.1、Maven 依赖 首先，我们要添加 spring-boot-starter-web 和 spring-cloud-starter-openfeign 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> 2.2、实现 Feign Client 现在，让我们使用 Spring Web 注解在 Feign 中实现 PATCH 方法。 首先，让我们建立一个 User model，它有几个简单的属性。 public class User { private String userId; private String userName; private String email; } 接下来，我们将使用 updateUser 方法来实现一个 UserClient 接口： https://springdoc.cn/spring-boot-development-mode-with-testcontainers-and-docker/ Sat, 02 Sep 2023 12:21:37 +0800 https://springdoc.cn/spring-boot-development-mode-with-testcontainers-and-docker/ 在本文中，你将学习如何使用 Spring Boot 内置的 Testcontainers 和 Docker Compose 支持，在开发模式下运行外部服务。Spring Boot 在当前的最新版本 3.1 中引入了这些功能，你已经可以在 Spring Boot 应用的测试中利用 Testcontainers。在应用程序启动时运行外部数据库、message broker 或其他外部服务的功能是我一直期待的。尤其是竞争框架 Quarkus 已经提供了名为 Dev Services 的类似功能，这在我的开发过程中非常有用。此外，还有另一个令人兴奋的功能 - 与 Docker Compose 集成。 源代码 如果你想自己尝试，可以查看我的源代码。因为我经常使用 Testcontainers，所以你可以在我的多个仓库中找到示例。下面是我们今天要使用的仓库列表： https://github.com/piomin/sample-spring-boot-on-kubernetes.git https://github.com/piomin/sample-spring-microservices-advanced.git https://github.com/piomin/sample-spring-kafka-microservices.git 你可以克隆它们，然后按照指导查看如何在开发模式下使用 Spring Boot 内置的 Testcontainers 和 Docker Compose 支持。 在测试中使用 Testcontainers 让我们从标准使用示例开始。第一个仓库中有一个连接 Mongo 数据库的 Spring Boot 应用程序。为了构建自动测试，我们必须包含以下 Maven 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.testcontainers</groupId> <artifactId>mongodb</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.testcontainers</groupId> <artifactId>junit-jupiter</artifactId> <scope>test</scope> </dependency> 现在，我们可以创建测试了。我们需要用 @Testcontainers 来注解我们的测试类。然后，我们必须声明 MongoDBContainer Bean。在 Spring Boot 3. https://springdoc.cn/spring-boot-built-in-testcontainers/ Sat, 02 Sep 2023 11:12:29 +0800 https://springdoc.cn/spring-boot-built-in-testcontainers/ 1、概览 在本教程中，我们将讨论 Spring Boot 3.1 中引入的增强型 Testcontainers 支持。 这个更新提供了一种更简化的配置容器的方法，并允许我们启动它们进行本地开发。因此，使用 Testcontainers 进行开发和运行测试变得更加无缝和高效。 2、SpringBoot 3.1 之前的 Testcontainers 在测试阶段，我们可以使用 Testcontainers 创建一个类似生产的环境。这样，我们就不需要模拟，就能写出与实现细节无关的高质量自动测试。 在本文的代码示例中，我们将使用一个简单的 Web 应用程序，其中包含一个 MongoDB 数据库作为持久层，并具有一个小型的 REST 接口。 @RestController @RequestMapping("characters") public class MiddleEarthCharactersController { private final MiddleEarthCharactersRepository repository; // constructor not shown @GetMapping public List<MiddleEarthCharacter> findByRace(@RequestParam String race) { return repository.findAllByRace(race); } @PostMapping public MiddleEarthCharacter save(@RequestBody MiddleEarthCharacter character) { return repository.save(character); } } 在集成测试期间，我们将启动一个包含数据库服务器的 Docker 容器。由于容器暴露的数据库端口将动态分配，我们无法在 properties 文件中定义数据库 URL。因此，对于版本早于 3.1 的 Spring Boot 应用程序，我们需要使用 @DynamicPropertySource 注解才能将这些属性添加到 DynamicPropertyRegistry 中： https://springdoc.cn/spring-boot-logging-tutorial/ Fri, 01 Sep 2023 12:18:42 +0800 https://springdoc.cn/spring-boot-logging-tutorial/ 日志系统对应用程序的重要性不言而喻。Spring Boot 为应用程序的日志记录提供了强大的支持，并提供了各种自定义选项。在本教程中，你将学习如何在 Spring Boot 应用程序中使用 Logback 和 Log4j2 实现日志记录 Spring Boot 中默认的的日志支持 当你创建一个添加了任何 starter 的 Spring Boot 应用程序时，它们都依赖于 spring-boot-starter，而 spring-boot-starter 又依赖于 spring-boot-starter-logging，这就为日志记录添加了 logback 依赖。 Spring Boot 默认日志配置已在 spring-boot-starter 中通过 CONSOLE appender 进行了配置。你可以在 org/springframework/boot/logging/logback 包下查看打包在 spring-boot.jar 中的默认配置文件（defaults.xml、base.xml、console-appender.xml、file-appender.xml）。 因此，默认情况下，Spring Boot 配置了 Slf4j 和 Logback 来记录日志，你可以在应用程序中按如下方式记录日志： import org.slf4j.Logger; import org.slf4j.LoggerFactory; @Service class CustomerService { private static final Logger log = LoggerFactory.getLogger(CustomerService.class); public Customer findById(Long id) { log.info("Fetching customer by id: {}", id); . https://springdoc.cn/contribute/ Fri, 01 Sep 2023 11:18:02 +0800 https://springdoc.cn/contribute/ 如果你想在这里分享你的内容，欢迎投稿有关 Spring 及其他相关主题的技术文章、新闻。 投稿要求 内容使用 Markdown 格式。 内容清晰易读，与 spring 及其他的主题相关。 文章中的媒体（图片，视频）资源，可以被 springdoc.cn 访问。 需要在文章末尾附上作者名称，作者网址，原文地址（如果有）。 投稿渠道 联系微信 KevinBlandy TODO https://springdoc.cn/springboot-datetime-format/ Fri, 01 Sep 2023 09:37:51 +0800 https://springdoc.cn/springboot-datetime-format/ Spring Boot 中默认使用的 JSON 框架是 jackson，它负责把 JSON 请求体反序列化为 Java 对象，并把响应给客户端的 Java 对象序列化为 JSON 字符串。 本文将会详细介绍如何在 Spring Boot 应用中自定义 jackson 对 Date、LocalDateTime、LocalDate 等日期对象的序列化、反序列化格式。 Jackson 对 Date/LocalDateTime/LocalDate 的默认处理方式 为了处理 java.time 类型的日期类，你还需要在项目中添加 com.fasterxml.jackson.datatype:jackson-datatype-jsr310 模块。 <dependency> <groupId>com.fasterxml.jackson.datatype</groupId> <artifactId>jackson-datatype-jsr310</artifactId> </dependency> 默认情况下，Jackson 将 Date 对象序列化为时间戳。对于 LocalDateTime 和 LocalDate 对象，jackson 会序列化为一个 long[]，其中，从第一个元素开始分别表示日期的：年、月、日、时、分、秒、毫秒。 示例： package cn.springdoc.test; import java.time.LocalDate; import java.time.LocalDateTime; import java.util.Date; import java.util.HashMap; import java.util.Map; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; public class JacksonTest { public static void main(String[] args) throws JsonProcessingException { ObjectMapper objectMapper = new ObjectMapper(); // 注册 JavaTime 模块 objectMapper. https://springdoc.cn/transaction-manager-in-spring/ Fri, 01 Sep 2023 08:47:56 +0800 https://springdoc.cn/transaction-manager-in-spring/ 事务管理 ，一个被说烂的也被看烂的话题，还是面试中常问到的问题之一。 本文会从设计角度，一步步的剖析 Spring 事务管理的设计思路（都会设计事务管理器了，还能玩不转？）。 一、为什么需要事务管理？ 先看看如果没有事务管理器的话，如果想让多个操作（方法/类）处在一个事务里应该怎么做： // MethodA: public void methodA(){ Connection connection = acquireConnection(); try{ int updated = connection.prepareStatement().executeUpdate(); methodB(connection); connection.commit(); }catch (Exception e){ rollback(connection); }finally { releaseConnection(connection); } } // MethodB: public void methodB(Connection connection){ int updated = connection.prepareStatement().executeUpdate(); } 或者用 ThreadLocal 存储 Connection？ static ThreadLocal<Connection> connHolder = new ThreadLocal<>(); // MethodA: public void methodA(){ Connection connection = acquireConnection(); connHolder.set(connection); try{ int updated = connection.prepareStatement().executeUpdate(); methodB(); connection.commit(); }catch (Exception e){ rollback(connection); }finally { releaseConnection(connection); connHolder. https://springdoc.cn/spring-rest-openapi-documentation/ Thu, 31 Aug 2023 15:34:30 +0800 https://springdoc.cn/spring-rest-openapi-documentation/ 1、概览 文档是构建 REST API 的重要组成部分。在本教程中，我们将介绍 Spring Doc，它可简化 API 文档的生成和维护，这些文档基于 OpenAPI 3 规范，适用于 Spring Boot 3.x 应用程序。 2、设置 springdoc-openapi Spring Boot 3.x 要求使用 springdoc-openapi version 2： <dependency> <groupId>org.springdoc</groupId> <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId> <version>2.1.0</version> </dependency> 2.1、 OpenAPI 描述的路径 正确设置依赖后，我们就可以运行应用程序，并在 /v3/api-docs 路径访问 OpenAPI 描述，这是默认路径： http://localhost:8080/v3/api-docs 此外，我们还可以使用 springdoc.api-docs 属性在 application.properties 中自定义描述的路径。例如，我们可以将路径设置为 /api-docs： springdoc.api-docs.path=/api-docs 然后，我们就可以通过以下网址访问文档描述： http://localhost:8080/api-docs OpenAPI 描述定义默认为 JSON 格式。对于 yaml 格式，我们可以从以下网址获取定义： http://localhost:8080/api-docs.yaml 3、整合 Swagger UI 除了生成 OpenAPI 3 规范之外，我们还可以将 springdoc-openapi 与 Swagger UI 集成，以与我们的 API 规范进行交互并测试端点。 Springdoc-openapi 依赖项中已经包含了 Swagger UI，因此我们可以通过如下路径访问 API 文档： https://springdoc.cn/introduction-to-grpc-with-spring-boot/ Thu, 31 Aug 2023 12:11:47 +0800 https://springdoc.cn/introduction-to-grpc-with-spring-boot/ 在本文中，你将学习如何在 Spring Boot 应用程序中实现使用 gRPC 进行通信。gRPC 是一个现代的开源远程过程调用（RPC）框架，可以在任何环境中运行。默认情况下，它使用 Google 的 Protocol Buffer 来对结构化数据进行序列化和反序列化。当然，我们也可以切换到其他数据格式，比如 JSON。为了简化我们在 gRPC 和 Spring Boot 中的使用体验，我们将使用一个专门的 starter。由于没有官方支持的 gRPC 和 Spring Boot 集成的 starter，我们将选择较流行的第三方项目 - grpc-spring-boot-starter。该项目在 GitHub 上有大约 3.1k 个星星。你可以在 这里 找到关于其功能的详细文档。 源码 如果你想亲自尝试，你可以克隆我的 GitHub 仓库。它包含四个应用程序。其中 account-service 和 customer-service 与我之前的文章相关，介绍了 Java 中的 Protocol Buffers。对于这篇文章，请参考另外两个应用 account-service-grpc 和 customer-service-grpc。它们与对应的前2个应用非常相似，但使用了我们的第三方 Spring Boot 和 gRPC 通信，而不是 REST。此外，它们需要使用 Spring Boot 2，因为我们的第三方 starter 还不支持 Spring Boot 3。无论如何，克隆了仓库后，只需按照我的说明进行操作即可。 生成 gRPC 的 Model 类和 service 第一步，我们将使用 .proto 文件生成 model 类和 gRPC service。我们需要加入一些额外的 Protobuf schema，以便使用 google. https://springdoc.cn/spring-boot-mybatis/ Thu, 31 Aug 2023 09:05:59 +0800 https://springdoc.cn/spring-boot-mybatis/ MyBatis 是一个流行的 Java 持久层框架，它简化了与关系型数据库的交互。通过将 SQL 语句与 Java 代码进行映射，MyBatis 提供了一种方便、灵活的方式来执行数据库操作。它支持动态SQL、缓存机制和插件扩展，使得开发人员能够更高效地编写和管理数据库访问代码。作为一种轻量级框架，MyBatis 在 Java 开发中被广泛应用于构建可靠的持久化解决方案。 本文将会指导你如何在 Spring Boot 中整合 MyBatis。 框架版本： Spring Boot：3.1.3 MyBatis：3.5.13 创建 Spring Boot 项目 通过 start.springboot.io 创建工程（你可以直接点击 这个链接 快速创建）。 选择 MySQL Driver、Spring Web、MyBatis Framework 基本依赖，点击 “GENERATE” 下载到本地后，导入到IDEA中。 本文将在示例中使用 MySQL 数据库，如果你使用其他类型的数据库，需要把 MySQL Driver 替换为对应的依赖。 配置项目 定义 mapper 接口 创建专门存放 mapper 接口的包： cn.springdoc.mapper，并在其中定义一个 FooMapper，如下： package cn.springdoc.mapper; import java.time.LocalDateTime; import org.apache.ibatis.annotations.Mapper; @Mapper // 使用 Mapper 注解 public interface FooMapper { /** * 获取数据库的当前时间 * @return */ LocalDateTime now(); } 该 Mapper 简单定义了一个 now 用于从数据库获取到当前时间。 https://springdoc.cn/spring-and-cors/ Wed, 30 Aug 2023 15:29:48 +0800 https://springdoc.cn/spring-and-cors/ 1、概览 在任何现代浏览器中，随着通过 REST API 获取数据的 HTML5 和 JS 客户端的出现，跨源资源共享 (CORS) 已成为一种相关规范。 通常，提供 JS 的主机（如 example.com）与提供数据的主机（如 api.example.com）不同。在这种情况下，CORS 可以实现跨域通信。 Spring 为 CORS 提供了一流的 支持，为在任何 Spring 或 Spring Boot Web 应用中配置 CORS 提供了简单而强大的方法。 2、Controller 方法级的 CORS 配置 启用 CORS 非常简单，只需添加注解 @CrossOrigin。 我们可以通过几种不同的方式来实现。 2.1、在 @RequestMapping 方法上注解 @CrossOrigin @RestController @RequestMapping("/account") public class AccountController { @CrossOrigin @RequestMapping(method = RequestMethod.GET, path = "/{id}") public Account retrieve(@PathVariable Long id) { // ... } @RequestMapping(method = RequestMethod.DELETE, path = "/{id}") public void remove(@PathVariable Long id) { // . https://springdoc.cn/spring-boot-webp-encode/ Wed, 30 Aug 2023 10:25:39 +0800 https://springdoc.cn/spring-boot-webp-encode/ WebP 是一种现代的图像格式，由 Google 开发。它采用了无损和有损的压缩算法，可以显著减小图像文件的大小，同时保持较高的视觉质量。WebP 图像通常比 JPEG 和 PNG 格式的图像更小，并且具有更快的加载速度，这对于 Web 应用程序和网页的性能优化非常有益。此外，WebP 还支持透明度和动画，使其成为一个多功能的图像格式。它已经得到了广泛的支持，包括主流的 Web 浏览器和图像处理软件。 简单理解就是：Webp编码格式的图片，体积更小，质量不减（肉眼很难看出质量差异），主流浏览器都支持。 据说使用 webp 编码的图片，有利于搜索引擎 SEO。 参考资料： Webp 官网 浏览器兼容情况 在 Java 中编码 Webp 图片 WEBP 官方开放了源码，以及编译后的可执行文件（可以通过命令行的形式对图片文件进行编码，解码处理），官方并未提供 Java 的 SDK。 我翻遍了互联网，在网上找到了一个开源的 webp 编码库：https://github.com/sejda-pdf/webp-imageio <!-- https://mvnrepository.com/artifact/org.sejda.imageio/webp-imageio --> <dependency> <groupId>org.sejda.imageio</groupId> <artifactId>webp-imageio</artifactId> <version>0.1.6</version> </dependency> 它貌似采用了 JNI 技术来调用 webp 的动态库来实现的编码。使用方式及其简单，如下： import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import java.io.InputStream; import javax.imageio.IIOImage; import javax.imageio.ImageIO; import javax.imageio.ImageWriteParam; import javax.imageio.ImageWriter; import javax.imageio.stream.FileImageOutputStream; import com.luciad.imageio.webp.WebPWriteParam; public class Webp { /** * 编码为WEBP * * @param in 输入文件 * @param file 输出文件 * @throws IOException */ public void encode(InputStream in, File file) throws IOException { // 读取图片文件 BufferedImage image = ImageIO. https://springdoc.cn/spring-boot-application-configuration-tutorial/ Tue, 29 Aug 2023 16:30:05 +0800 https://springdoc.cn/spring-boot-application-configuration-tutorial/ 在上一篇 Spring Boot 测试教程 中，我们学习了如何为 Spring Boot 应用编写单元测试、片段测试和集成测试。 在本教程中，你将学习如何使用 properties 和 YAML 文件配置 Spring Boot 应用程序，以便在不同环境中运行应用。 外部化 Spring Boot 的配置 大多数应用程序都会有一些配置项目，你希望这些项目是可以灵活配置的，而不是在程序代码中硬编码这些值。 Spring Boot 提供了许多 配置 application properties 的方法，其中我们最有可能使用的只有以下方法： 默认 src/main/resources/application.{properties/yml} 中的属性值。 特定 profile src/main/resources/application-{profile}.{properties/yml} 中的属性值。 使用环境变量（Environment Variables）或系统属性（System Properties）覆盖默认配置。 在我们的应用程序中，通常会有两种配置属性： Spring Boot 定义了用于配置 DataSource、Kafka 等服务的属性。例如：spring.datasource.url、spring.datasource.username、spring.datasource.password 等。 应用特定的配置属性。 配置默认属性 Spring Boot 默认从 src/main/resources/application.{properties/yml} 中加载属性。例如，我们可以使用 application.properties 文件配置应用属性，如下所示： spring.datasource.url=jdbc:postgresql://localhost:5432/postgres spring.datasource.username=postgres spring.datasource.password=secret123 ftp.host=ftpsrv001 ftp.port=21 ftp.username=appuser1 ftp.password=secret321 同样的配置值也可以使用 application.yml 文件进行配置，如下所示： spring: datasource: url: jdbc:postgresql://localhost:5432/postgres username: postgres password: secret123 ftp: host: ftpsrv001 port: 21 username: appuser1 password: secret321 配置特定于 Profile 的属性 我们的应用可能会在不同的环境中运行，如本地、开发、QA、暂存和生产环境。我们可能希望为不同的环境配置不同的值。在这种情况下，我们可以使用 Spring 的 profile 概念来为不同环境配置不同的值。 https://springdoc.cn/spring-cors/ Tue, 29 Aug 2023 10:25:55 +0800 https://springdoc.cn/spring-cors/ 如果你从事 web 应用开发，在前端使用异步请求（fetch/XMLHttpRequest）时，那你或多或少都应该在浏览器控制台见识过如下异常信息。 Access to fetch at 'http://localhost:8080/hello' from origin 'http://localhost:1313' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled. 是的，这就是在异步请求时跨域失败的异常信息。接下来本文将会先简单地介绍跨域的基础知识，再详细地介绍如何在 spring 应用中处理跨域。 简单了解跨域 跨域，全称为“跨域资源共享”（Cross-origin resource sharing），是浏览器的一种安全机制。只会在浏览器中，使用 AJAX （fetch/XMLHttpRequest）时发生。当你在一个 web 页面中，使用 ajax 对目标 URL 发起了请求，只要目标 URL 的 协议，主机，端口 和当前 web 页面的 协议，主机，端口 任意不一致，就会产生跨域。 例如，我在页面 http://localhost:1313 中，对如下 URL 发起 AJAX 请求，都会导致跨域: https://springdoc.cn/comments/ Mon, 28 Aug 2023 17:40:41 +0800 https://springdoc.cn/comments/ Github 资源加载缓慢，请耐心一点点。 https://springdoc.cn/spring-boot-testing-tutorial/ Mon, 28 Aug 2023 13:10:49 +0800 https://springdoc.cn/spring-boot-testing-tutorial/ 在前面的 Spring Boot 入门教程 中，我们学习了如何创建 Spring Boot 应用程序并构建一个简单的 REST API。 在本教程中，你将学习如何为 Spring Boot 应用程序编写单元测试、片段测试和集成测试。 测试 Spring Boot 应用 我们应该编写单元测试来验证特定单元（一个类、一个方法或一组类）的业务逻辑，而且它们不应该与任何外部服务（如数据库、队列或其他网络服务等）有联系。如果我们测试的单元依赖于任何外部服务，那么我们可以提供这些依赖关系的模拟（mock）实现，并验证单元的行为。 除了单元测试外，我们还应该编写集成测试，通过与实际服务和依赖的协作者（dependent collaborator）互动来检验子系统或组件的行为。 当我们生成 Spring Boot 应用程序时，会自动添加 spring-boot-starter-test 依赖项，它可以将 SpringTest、JUnit5、Mockito、Assertj、JsonPath、JsonAssert 等最常用的测试库作为测试依赖项添加到我们的应用程序中。 测试的类型 Unit Tests（单元测试）： 这些测试用于验证单个单元的行为，最好不要依赖 Spring 或 Hibernate 等框架。 Slice Tests（片段测试）： 这些测试用于验证应用程序的某个片段，如 Web 层或持久层等。Spring Boot 支持使用 @WebMvcTest、@DataJpaTest、@DataMongoTest 等测试应用程序的片段。 Integration Tests（集成测试）： 这些测试以黑盒方式测试应用程序。我们传入一些输入，并期待特定的输出，但我们不知道也不关心内部是如何工作的。Spring Boot 支持使用 @SpringBootTest 编写集成测试。 使用 JUnit 5 和 Mockito 进行单元测试 我们将为之前的 Spring Boot 入门教程 中实现的 REST API 编写测试。 让我们从编写 GreetingService 的单元测试开始。我们将使用 JUnit 5 和 Mockito 来编写单元测试。 https://springdoc.cn/logging-in-spring-boot-with-loki/ Mon, 28 Aug 2023 12:37:29 +0800 https://springdoc.cn/logging-in-spring-boot-with-loki/ 在本文中，你将学习如何收集 Spring Boot 应用程序日志并将其发送到 Grafana Loki。为此，我们将使用 Loki4j Logback appender 功能。Loki 是一个受 Prometheus 启发的可水平扩展、高度可用的日志聚合系统。我将逐步展示如何配置应用程序与 Loki 之间的集成。不过，你也可以使用我自动配置的用于记录 HTTP 请求和响应的库，它将为你完成所有这些步骤。 源码 如果你想自己尝试，可以克隆我的 GitHub 仓库。点击 此处 查看包含我的自定义 Spring Boot 日志库的源代码仓库。然后按照我的说明操作即可。 使用 Loki4j Logback Appender 为了使用 Loki4j Logback Appender，我们需要在 Maven pom.xml 中加入一个依赖。该库的当前版本为 1.4.1： <dependency> <groupId>com.github.loki4j</groupId> <artifactId>loki-logback-appender</artifactId> <version>1.4.1</version> </dependency> 然后，我们需要在 src/main/resources 目录下创建 logback-spring.xml 文件。我们的 Loki 实例在 http://localhost:3100 地址 (1) 下可用。Loki 不会索引日志内容，只会索引元数据标签。有一些静态标签，如应用程序名称、日志级别或主机名。我们可以在 format.label 字段 (2) 中设置它们。我们还将设置一些动态标签，因此要启用日志回溯标记功能 (3)。最后，我们将设置日志格式模式 (4)。为了简化 LogQL（Loki 查询语言）的潜在转换，我们将使用 JSON 符号。 <?xml version="1.0" encoding="UTF-8"?> <configuration> <springProperty name="name" source="spring. https://springdoc.cn/jpa-no-argument-constructor-entity-class/ Mon, 28 Aug 2023 12:12:55 +0800 https://springdoc.cn/jpa-no-argument-constructor-entity-class/ 1、概览 在本教程中，我们将学习在 JPA 中，为什么实体类必须要有默认无参数构造函数？ 为了理解无参数构造函数的意义，我们将使用一个简单的 Employee 实体示例。我们将观察缺少默认构造函数是如何导致编译时错误的。我们将深入探讨 JPA 在实体实例化中对 Reflection 的使用。此外，我们还将简要介绍这些类中可能需要该构造函数的其他原因。 2、示例 让我们举一个简单的例子，建立一个名为 Employee 的实体类，其中包含 name、department 和自动生成的 id。让我们定义一个包含所有三个字段的构造函数： @Entity public class Employee { @Id private Long id; private String name; private int age; public Employee(Long id, String name, int age) { this.id = id; this.name = name; this.age = age; } // get 和 set } 不过，此时我们会发现 Employee 类无法编译：Class'Employee' should have [public, protected] no-arg constructor。 显然，在这里我们可以看到，我们定义了一个带有全参构造函数的 Entity 类，但却没有无参数构造函数。在这种情况下，会出现一个编译时错误，提示我们除了现有的构造函数外，还需要一个无参数构造函数。 在接下来的两节中，我们将围绕 Entity 类中的构造函数了解 JPA 规范。我们将了解如何修复错误，以及 JPA 施加这些约束的根本原因。 https://springdoc.cn/spring-data-jpa-findby-vs-findoneby/ Sun, 27 Aug 2023 10:39:57 +0800 https://springdoc.cn/spring-data-jpa-findby-vs-findoneby/ 1、概览 Spring Data Repository 提供了大量可简化数据访问逻辑实现的方法。然而，选择合适的方法并不总是像我们想象的那么容易。 以 findBy 和 findOneBy 为前缀的方法就是一个例子。尽管从名称上看，它们似乎做着同样的事情，但其实还是有一些区别的。 2、Spring Data 中的派生查询方法 Spring Data JPA 的派生查询方法功能经常受到称赞。这些方法提供了一种从方法名称派生特定查询的方法。例如，如果我们想通过 foo 属性检索数据，只需写 findByFoo() 即可。 通常，我们可以使用多个前缀来构建派生查询方法。这些前缀包括 findBy 和 findOneBy。下面，我们就来看看它们的实际应用。 3、实例 首先，我们来看看 Person 实体类： @Entity public class Person { @Id private int id; private String firstName; private String lastName; // 标准的 get 和 set 方法 } 在这里，我们将使用 H2 作为数据库。让我们使用一个基本的 SQL 脚本为数据库添加数据： INSERT INTO person (id, first_name, last_name) VALUES(1, 'Azhrioun', 'Abderrahim'); INSERT INTO person (id, first_name, last_name) VALUES(2, 'Brian', 'Wheeler'); INSERT INTO person (id, first_name, last_name) VALUES(3, 'Stella', 'Anderson'); INSERT INTO person (id, first_name, last_name) VALUES(4, 'Stella', 'Wheeler'); 最后，让我们创建一个 JPA repository 来管理我们的 Person 实体： https://springdoc.cn/privacy/ Sat, 26 Aug 2023 13:18:34 +0800 https://springdoc.cn/privacy/ SPRINGDOC.CN 是一个完完全全的静态内容网站，我们不收集用户的任何个人信息。我们不使用 cookie 或任何其他跟踪技术来收集有关你访问我们网站的任何信息。 https://springdoc.cn/reactive-spring-boot-with-webflux-r2dbc-and-postgres/ Sat, 26 Aug 2023 12:30:38 +0800 https://springdoc.cn/reactive-spring-boot-with-webflux-r2dbc-and-postgres/ 在本文中，你将学习如何使用 Spring WebFlux、R2DBC 和 Postgres 数据库实现和测试响应式（Reactive） Spring Boot 应用程序。我们将使用最新版本的 Spring Boot 3 创建两个用 Kotlin 编写的简单应用程序。我们的应用程序通过 HTTP 公开一些 REST 端点。为了测试它们之间的通信以及与 Postgres 数据库的集成，我们将使用 Testcontainers 和 Netty Mock Server。 源码 你可以可以克隆我的 GitHub repository。它包含 employee-service 和 organization-service 两个应用程序。之后，你只需按照我的说明操作即可。 依赖 第一步，我们将添加几个与 Kotlin 相关的依赖。除了标准库，我们还可以加入 Kotlin 对 Jackson（JSON 序列化/反序列化）的支持： <dependency> <groupId>org.jetbrains.kotlin</groupId> <artifactId>kotlin-stdlib</artifactId> </dependency> <dependency> <groupId>com.fasterxml.jackson.module</groupId> <artifactId>jackson-module-kotlin</artifactId> </dependency> <dependency> <groupId>org.jetbrains.kotlin</groupId> <artifactId>kotlin-reflect</artifactId> </dependency> 我们还需要包含两个 Spring Boot Starter。为了创建响应式 Spring @Controller，我们需要使用 Spring WebFlux 模块。有了 Spring Boot Data R2DBC Starter，我们就能以响应方式使用 Spring Data Repository。最后，我们还需要加入 R2DBC 提供的 Postgres 驱动程序。 https://springdoc.cn/java-openapi-lombok-create-models/ Sat, 26 Aug 2023 09:40:02 +0800 https://springdoc.cn/java-openapi-lombok-create-models/ 1、概览 Lombok 是一个 Java 库，有助于减少 getter、setter 等模板代码。OpenAPI 提供了一个属性，用于自动生成带有 Lombok 注解的 Model。 在本教程中，我们将探讨如何使用 OpenAPI 代码生成器生成带有 Lombok 注解的 Model。 2、项目设置 首先，让我们创建一个 Spring Boot 项目，并添加 Spring Boot Starter Web 和 Lombok 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>3.1.2</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.28</version> <scope>provided</scope> </dependency> 此外，我们还需要 Swagger 注解、Gson 和 Java Annotation API 依赖，以防止在生成的代码中出现与包相关的错误： <dependency> <groupId>javax.annotation</groupId> <artifactId>javax.annotation-api</artifactId> <version>1.3.2</version> </dependency> <dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> <version>2.10.1</version> </dependency> <dependency> <groupId>io.swagger</groupId> <artifactId>swagger-annotations</artifactId> <version>1.6.2</version> </dependency> 在下一节中，我们将为一个名为 Book 的 model 创建一个 API 规范，然后使用 OpenAPI 代码生成器生成带有 Lombok 注解的代码。 https://springdoc.cn/getting-started-with-spring-boot/ Fri, 25 Aug 2023 14:56:18 +0800 https://springdoc.cn/getting-started-with-spring-boot/ Spring Boot 介绍 Spring Boot 是 Java 世界中最流行的应用程序构建框架。Spring Boot 是一种基于约定而非配置的方法，用于构建基于 Spring 框架的应用程序。 使用 Spring Boot，你可以构建单体应用程序、微服务、serverless 应用程序、批处理应用程序等不同类型的应用程序。 让我们快速了解一下 Spring Boot 有哪些关键功能使其如此受欢迎。 Spring Boot 关键特性 自动配置 Spring Boot 对应用程序有自己的约定，它会根据默认约定自动配置组件（又称 Bean），而不需要你显式配置所有内容。不过，如果需要，你可以通过各种方式自定义或覆盖 Bean 配置。 例如，如果添加 spring-boot-starter-data-jpa 依赖，它将添加 Hibernate 作为 JPA 实现，因为它是最常用的 JPA 提供程序。此外，Spring Boot 还会自动配置使用 Spring Data Jpa 所需的组件，如 DataSource、EntityManagerFactory、PlatformTransactionManager 等。如果 classpath 中存在内存 JDBC 驱动程序（如 H2 或 HSQL），那么 Spring Boot 将自动配置基于内存的数据源。 如果要使用 MySQL、Postgresql 等非内存数据库，可以添加相应的 JDBC 驱动程序 jar，并在 application.properties 文件中配置 JDBC 连接参数。然后，Spring Boot 将使用这些属性来配置 DataSource Bean，而不是使用默认的内存数据库。你甚至可以使用 @Bean 注解自行配置 DataSource Bean，然后 Spring Boot 将回退并使用你配置的 DataSource Bean，而不是自动配置。 https://springdoc.cn/pdf/ Fri, 25 Aug 2023 14:06:16 +0800 https://springdoc.cn/pdf/ PDF 文档的内容与 springdoc.cn 中文档的内容完全一致，如果你确实想要一份可以离线查阅的PDF文档，可以关注微信公众号获取，或者通过捐赠来订阅最新的文档。 关注微信公众号 账号：springboot_io 扫码： 回复： pdf （获取文档下载地址） 并不经常维护微信公众号，所以这种方式下载的PDF版本不一定是最新的。 通过捐赠订阅更新 由于失业、官方文档结构变更等问题，一直没有时间去更新最新的文档。目前所维护最新 PDF 文档版本为 2023 年 9 月份 更新的 spring 6 和 springboot 3.2.0（和网页文档一致）。 总之，不确定未来什么时候才会去更新最新版本的中文文档，所以，不建议 通过捐赠订阅更新 了。 再次感谢当初捐赠社区的用户，谢谢。 你可以考虑捐赠 18￥，成为捐赠者，来支持我们的翻译和维护工作。 springdoc.cn 每一次和官方文档进行同步更新后，我们会专门为你打包一份最新的PDF文档，以及本次更新内容的说明。 目前仅提供部分文档的PDF文档。我们也承诺，在其他技术文档的翻译工作完毕后，我们也会尝试打包其对应的PDF文档，并且免费提供给捐赠者。 捐赠方式 【推荐】添加微信好友 （微信订阅更新） 直接添加管理员微信（KevinBlandy）后捐赠（直接转账，红包都可以），备注说明：“捐赠”。 支付宝/微信 扫码捐赠 （邮箱订阅更新） 请一定要在转账备注中留下你的邮箱，我们每次更新会通过邮箱给你发送最新的PDF文件。 微信 支付宝 PDF文档预览 https://springdoc.cn/spring-data-jpa-scroll-api/ Fri, 25 Aug 2023 13:39:06 +0800 https://springdoc.cn/spring-data-jpa-scroll-api/ 1、概览 Spring Data Commons 是总括 Spring Data project 的一部分，其中包含管理持久层的接口和实现。Scroll API 是 Spring Data Commons 提供的功能之一，用于处理从数据库读取的大型结果。 在本教程中，我们将通过一个示例探索 Scroll API。 2、依赖 Spring Boot 3.1 版本新增了 Scroll API 支持。Spring Data Commons 已包含在 Spring Data JPA 中。因此，添加 Spring Data JPA 3.1 版本就可以获得 Scroll API 功能： <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-jpa</artifactId> <version>3.1.0</version> </dependency> 最新的版本可在 Maven 中央仓库 中找到。 3、 Entity 类 例如，我们将使用 BookReview 实体，它包含不同用户对不同书籍的书评评级： @Entity @Table(name="BOOK_REVIEWS") public class BookReview { @Id @GeneratedValue(strategy= GenerationType.SEQUENCE, generator = "book_reviews_reviews_id_seq") @SequenceGenerator(name = "book_reviews_reviews_id_seq", sequenceName = "book_reviews_reviews_id_seq", allocationSize = 1) private Long reviewsId; private String userId; private String isbn; private String bookRating; // getter 和 setter 方法 } 4、Scroll API Scroll API 提供了分块迭代大型结果的功能。它提供稳定的排序、scroll 类型和结果限制。 https://springdoc.cn/maven-fast-build/ Thu, 24 Aug 2023 19:57:37 +0800 https://springdoc.cn/maven-fast-build/ 1、概览 在本教程中，我们将学习如何加快 Maven 的构建速度。我们将介绍各种优化构建时间的技术，并评述其优缺点。 2、常规建议 使用正确的 maven phase（阶段） 可以为我们节省大量时间。如果只需要编译代码，就没必要运行完整的 install，并且这会污染我们的本地仓库。 在多模块项目中，可以只重建已更改的模块和依赖于这些模块的模块。例如，如果我们只修改了 module1 和 module2，我们可以运行： $ mvn clean install -pl module1,module2 -am 3、使用多线程 默认情况下，Maven 构建在单线程中顺序运行。不过，如今所有电脑都有多核。让我们利用这一点，使用 -T 选项并行构建我们的模块： $ mvn clean install -T 1C -T 1C 表示 Maven 将在每个可用内核上使用一个线程。 -T 4 会强制 Maven 使用四个线程。 -T auto 会让 Maven 决定使用的线程数。 最后但并非最不重要的一点是，Maven Reactor 可确保所有相互依赖的模块按顺序运行。 4、测试优化 测试是软件开发的重要组成部分。然而，运行测试需要花费大量时间。 4.1、并行运行测试 默认情况下，Surefire 插件会按顺序运行单元测试。不过，我们可以将其配置为并行运行。例如，要并行运行所有测试套件，并在每个可用内核上使用一个线程，我们可以运行： mvn clean install -Dparallel=all -DperCoreThreadCount=true 但是，如果我们的项目中没有大量的单元测试，并行化的开销可能会导致更低的效率。 4.2、跳过测试执行 有时，我们并不需要在本地环境中运行测试。Maven -DskipTests 选项会跳过测试的执行，但仍会编译 test 文件夹： $ mvn clean install -DskipTests 在高度测试的项目中，当我们不需要测试时，跳过测试可以节省我们的时间！ https://springdoc.cn/spring-boot-3-observability/ Thu, 24 Aug 2023 19:55:40 +0800 https://springdoc.cn/spring-boot-3-observability/ 1、概览 在本文中，我们将学习如何在 Spring Boot 3 配置可观察性（observability）。可观察性是一种仅通过外部输出来衡量系统内部状态的能力。 此外，我们必须注意 Spring Boot 2（Spring 5）和 Spring Boot 3（Spring 6）之间的重大变化。Spring 6 引入了 Spring Observability，这是一项建立在 Micrometer 和 Micrometer Tracing（原 Spring Cloud Sleuth）基础上的新举措。它更适合使用 Micrometer 高效记录应用指标，并通过 OpenZipkin 的 Brave 或 OpenTelemetry 等 provider 实现追踪。Spring Observability 优于“基于代理的可观察性解决方案”，因为它能在原生编译的 Spring 应用程序中无缝运行，并能更有效地提供更好的信息。 我们只介绍有关 Spring Boot 3 的详细信息。如果要从 Spring Boot 2 迁移，可以在这里找到详细说明。 2、Micrometer Observation API Micrometer 是一个独立于供应商中立的“应用度量 facade”的项目。它定义了 meter、rate aggregation、counter、gauge 和 timer 等概念，每个供应商都可以根据自己的概念和工具进行调整。其中一个核心部分是 Observation API，它允许对代码进行一次性的仪表化，并具有多种优势。 仪表化是指在代码中添加监测点或仪表，以便收集关于代码执行过程的信息。这些监测点可以是特定的观测点或代码片段，用于捕获代码的执行路径、变量状态、函数调用和其他相关信息。这些信息对于代码性能分析、调试和优化非常有用。 它是 Spring Framework 多个部分的依赖项之一，因此我们需要了解这个 API，才能理解 Spring Boot 中的观察功能是如何工作的。我们可以通过一个简单的示例来实现这一点。 https://springdoc.cn/spring-boot-apache-pulsar/ Thu, 24 Aug 2023 19:53:31 +0800 https://springdoc.cn/spring-boot-apache-pulsar/ 1、概览 Apache Pulsar 是一个分布式发布/订阅消息系统。Apache Pulsar 提供的功能与 Apache Kafka 类似，但 Pulsar 的目标是克服 Kafka 的高延迟、低吞吐量、难以扩展和地理复制等局限性。在处理需要实时处理的大量数据时，Apache Pulsar 是一个不错的选择。 在本教程中，我们将学习如在 Spring Boot 应用中整合 Apache Pulsar，以及如何使用 Pulsar 的 Spring Boot Starter 提供的 PulsarTemplate 和 PulsarListener。我们还将了解如何根据自己的需求修改它们的默认配置。 2、Maven 依赖 首先，先根据 Apache Pulsar 简介中所述，运行独立的 Apache Pulsar 服务器。 然后，将 spring-pulsar-spring-boot-starter 库添加到项目中： <dependency> <groupId>org.springframework.pulsar</groupId> <artifactId>spring-pulsar-spring-boot-starter</artifactId> <version>0.2.0</version> </dependency> 3、PulsarClient 要与 Pulsar 服务器交互，我们需要配置一个 PulsarClient。默认情况下，Spring 会自动配置一个 PulsarClient，连接到 localhost:6650 上的 Pulsar 服务器： spring: pulsar: client: service-url: pulsar://localhost:6650 我们可以更改配置，从自定义的地址上建立连接。 要连接到 ssl 下的 pulsar 服务器 ，可以使用 “pulsar+ssl” 代替 “pulsar”。我们还可以通过在 application. https://springdoc.cn/creating-a-fat-jar-app-with-spring-boot/ Thu, 24 Aug 2023 19:52:05 +0800 https://springdoc.cn/creating-a-fat-jar-app-with-spring-boot/ 在本指南中，我将向你展示如何使用 Spring Boot 创建 Fat Jar。我们将一起构建一个简单的 “UsersMicroservice”，然后将其打包到 Fat Jar 中。如果你是新手，也不用担心，我会一步一步地指导你，并回答你在使用过程中遇到的各种问题。 Fat JAR 是啥？ Fat JAR 通常也称为 uber-JAR，是一种 Java 归档 (JAR) 文件，它不仅包括应用程序的编译源代码，还包括运行应用程序所需的所有依赖项和资源。这些依赖项可能包括库、框架，甚至是嵌入式服务器，如 Tomcat 或 Jetty，这些通常在 Spring Boot 应用中使用。 换句话说，Fat JAR 是一个独立可直接运行的软件包。与普通 JAR 文件不同的是，普通 JAR 文件在运行应用程序时可能需要在 classpath 中存在外部依赖，而 Fat JAR 文件则完全自给自足，可以在任何已安装 Java 虚拟机（JVM）的系统上运行，无需安装或设置任何额外的依赖。 为什么使用 Fat JAR？ 使用 Fat JAR 有几个好处： 简单： 由于 Fat JAR 包已经含运行应用程序所需的所有内容，因此它简化了部署过程。没有在部署环境中设置和管理外部依赖的负担。 可移植性： 你可以在任何支持 JVM 的平台上运行 fat JAR。这使得它具有极高的可移植性，非常适合各种环境，包括不同的开发、测试、暂存和生产设置。 微服务架构： Fat JAR 在微服务架构中尤其有用。在这种架构风格中，每个微服务通常都是一个独立的应用程序，可以独立开发、部署和扩展。将每个微服务打包为 Fat JAR，可以方便地分别管理和部署每个服务。 一致性： 将应用程序打包为 fat JAR 时，可以确保在构建和运行应用程序时使用同一套依赖。这有助于避免在构建和运行时使用不同版本的依赖时可能出现的问题。 尽管有这些优点，但也要注意 fat JAR 的缺点。fat JAR 可能比普通 JAR 大得多，这会减慢构建和启动速度，并占用更多资源。此外，如果同一系统中的多个 fat JAR 使用相同的依赖，这可能会导致冗余，因为每个 JAR 都包含每个依赖的副本。 https://springdoc.cn/spring-boot-3-error-reporting-using-problem-details/ Thu, 24 Aug 2023 19:50:00 +0800 https://springdoc.cn/spring-boot-3-error-reporting-using-problem-details/ Spring Framework 6 实现了 “Problem Details for HTTP APIs（HTTP API 的问题细节规范）”（RFC 7807）。在本文中，我们将学习如何在 SpringBoot 3 REST API（使用 Spring Framework 6）中处理异常，并使用 ProblemDetails API 提供错误响应。 假设我们有以下 REST API 端点，用于创建书签（bookmark）和按 ID 获取书签。 @RestController @RequestMapping("/api/bookmarks") @RequiredArgsConstructor public class BookmarkController { private final BookmarkService service; @PostMapping public ResponseEntity<Bookmark> save(@Valid @RequestBody Bookmark payload) { Bookmark bookmark = new Bookmark(null, payload.title(), payload.url(), Instant.now()); return ResponseEntity.status(HttpStatus.CREATED).body(service.save(bookmark)); } @GetMapping("/{id}") public ResponseEntity<Bookmark> getBookmarkById(@PathVariable Long id) { return service.getBookmarkById(id) .map(ResponseEntity::ok) .orElseThrow(() -> new BookmarkNotFoundException(id)); } } 而且，BookmarkNotFoundException 是一种典型的 RuntimeException，具体如下： https://springdoc.cn/spring-boot-api-key-secret/ Thu, 24 Aug 2023 19:47:34 +0800 https://springdoc.cn/spring-boot-api-key-secret/ 1、概览 安全在 REST API 开发中起着至关重要的作用。不安全的 REST API 可以直接访问后端系统的敏感数据。因此，企业需要关注 API 的安全性。 Spring Security 提供了各种机制来保护我们的 REST API。其中之一就是 API key。API key 是客户端在调用 API 时提供的 Token。 在本教程中，我们将讨论 Spring Security 中基于 API key 的身份认证的实现。 2、REST API 安全 Spring Security 可用于保护 REST API。REST API 是无状态的。因此，它们不应使用会话或 cookie。相反，它们应该使用 Basic authentication、API key、JWT 或基于 OAuth2 的 token 来确保安全。 2.1、Basic Authentication Basic authentication 是一种简单的身份认证方案。客户端发送 HTTP 请求时，Authorization 包含 Basic 字样，后面跟一个空格和一个 Base64 编码的字符串 username:password。Basic authentication 只有在使用 HTTPS/SSL 等其他安全机制时才被认为是安全的。 2.2、OAuth2 OAuth2 是 REST API 安全性的事实标准。它是一个开放的身份认证和授权标准，允许资源所有者通过 access token 权客户端访问私有数据。 https://springdoc.cn/eureka-server-cluster-setup-tutorial/ Thu, 24 Aug 2023 19:44:00 +0800 https://springdoc.cn/eureka-server-cluster-setup-tutorial/ 在本教程中，你将学习到如何在本地计算机上设置 Eureka Cluster（集群）。虽然本文是在本地计算机上设置的 Eureka Cluster，但你仍然可以学到如何让 Eureka 在远程服务器上运行。 什么是 Eureka 服务器集群？ Eureka 服务器集群又称 Eureka 节点感知（Peer Awareness）系统，是一组相互通信的 Eureka 服务器。不过，这不是普通的服务器群。它们可以相互通信，共享注册服务的相关信息。这意味着即使其中一台服务器宕机，其他服务器仍能提供必要的服务信息，确保高可用性和容错性。这是一项关键功能，使 Eureka 服务器集群成为大型系统的绝佳选择，在这种系统中，宕机的代价可能很高。 现在，你可能会问，为什么我们需要这样的设置。好吧，把它想象成一个图书管理员团队，他们总是相互通报庞大图书馆中书籍的最新情况。如果其中一个人不在，其他人仍然可以为你找到你要的书提供指导。同样，Eureka 服务器集群可确保你的微服务始终能找到彼此，即使在服务器出现故障的情况下也是如此。正是它们的团队合作使你的微服务架构变得稳健而富有弹性。 在接下来的章节中，我将指导你建立自己的 Eureka 服务器集群。 创建 Eureka Server 项目 我们首先要做的是创建一个新的 Spring Boot 项目。为此，我们将使用 Spring Initializr 来快速创建我们的项目。创建项目时，我们需要确保添加一个名为 Eureka Server 的重要依赖项。该依赖将把我们的普通 Spring Boot 项目转变为 Eureka Server。如果你现在还不清楚如何操作，也不用担心。我们将在下一步了解详情。 必须的 Maven 依赖 如果使用 Spring Initializr 工具创建了项目，并添加了 Eureka Server 依赖，则应在项目的 pom.xml 文件中看到以下依赖。 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId> </dependency> 在我的案例中，完整的 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. https://springdoc.cn/spring-data-jpa-pagination-sorting/ Thu, 24 Aug 2023 19:42:45 +0800 https://springdoc.cn/spring-data-jpa-pagination-sorting/ 1、概览 当我们数据库中的记录数量较多的时候，一般不会一次性检索出所有记录，通常会通过分页的方式展现。 此外，我们还经常需要在分页时根据某些条件对数据进行排序。 在本教程中，我们将学习如何使用 Spring Data JPA 轻松实现分页和排序。 2、创建实体 首先，假设我们有一个 Product 实体作为 domain 类： @Entity public class Product { @Id private long id; private String name; private double price; // 构造函数, getter 和 setter } 我们的每个 Product 实例都有一个唯一的标识符： id、name 和 price。 3、创建 Repository 要访问我们的 Product，我们需要一个 ProductRepository： public interface ProductRepository extends PagingAndSortingRepository<Product, Integer> { List<Product> findAllByPrice(double price, Pageable pageable); } 通过让它继承 PagingAndSortingRepository，我们可以使用，用于分页和排序的 findAll(Pageable pageable) 和 findAll(Sort sort) 方法。 相反，我们也可以选择继承 JpaRepository，因为它也继承了 PagingAndSortingRepository。 https://springdoc.cn/docker-compose-support-spring-boot/ Thu, 24 Aug 2023 19:40:39 +0800 https://springdoc.cn/docker-compose-support-spring-boot/ 1、概览 Spring Boot 3 具有一些新功能，比如将我们的应用程序构建为 GraalVM Native Image（原生镜像）。另一个相关支持是 Docker Compose。 在本教程中，我们将了解如何将 Docker Compose 工作流与 Spring Boot 3 整合。 2、Spring Boot 3 的 Docker Compose Support 提供了什么？ 通常，我们会根据 docker-compose.yml 运行 docker-compose up 来启动和 docker-compose down 来停止我们的容器。现在，我们可以将这些 Docker Compose 命令委托给 Spring Boot 3。当 Spring Boot 应用程序启动或停止时，它也会管理我们的容器。 此外，它还内置了对多种服务的管理，如 SQL 数据库、MongoDB、Cassandra 等。因此，我们可能不需要在 application 资源文件中重复配置 class 或 properties。 最后，我们会看到如何在该支持中使用自定义 Docker 镜像和 Docker Compose profiles 。 3，设定 我们需要 Docker Compose 和 Spring Boot 3 来探索这种新的支持。 3.1、Docker Compose Docker Compose 需要已安装的 Docker 引擎。它们很容易安装，不过根据操作系统的不同可能会有差异。 https://springdoc.cn/using-java-records-with-spring-boot-3/ Thu, 24 Aug 2023 19:38:49 +0800 https://springdoc.cn/using-java-records-with-spring-boot-3/ Record 在 Java 14 中作为预览功能引入，并在 JDK 16 中成为标准功能。Record 是不可变数据类（data class）的简洁表示。 在使用 Record 之前，我们通常是这样创建不可变 class 的。 import java.util.Objects; class Person { private final Long id; private final String name; public Person(Long id, String name) { this.id = id; this.name = name; } public Long getId() { return this.id; } public String getName() { return this.name; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() ! https://springdoc.cn/java-servletrequest-illegalstateexception/ Thu, 24 Aug 2023 19:37:18 +0800 https://springdoc.cn/java-servletrequest-illegalstateexception/ 1、介绍 有时，当我们在 Java Web 应用程序中调用 ServletRequest 接口的 getReader() / getInputStream()方法时，可能会出现IllegalStateException 异常，异常信息为：“getInputStream() has already been called for this request”。 在本教程中，我们将了解出现这种异常的原因和解决方法。 2、问题与原因 Java Servlet 规范，用于用 Java 构建 Web 应用程序。它定义了 ServletRequest / HttpServletRequest 接口，以及 getReader() 和 getInputStream() 方法，用于从 HTTP 请求中读取数据。 getReader() 方法以字符数据形式返回请求体，而 getInputStream() 方法则以二进制数据形式返回请求体。 getReader() 和 getInputStream() 的 Servlet API 文档强调，它们不能同时使用： public java.io.BufferedReader getReader() Either this method or getInputStream may be called to read the body, not both. ... Throws: java.lang.IllegalStateException - if getInputStream() method has been called on this request public ServletInputStream getInputStream() Either this method or getReader may be called to read the body, not both. https://springdoc.cn/spring-bean-scope-guides/ Thu, 24 Aug 2023 19:35:21 +0800 https://springdoc.cn/spring-bean-scope-guides/ 在本教程中，将带你学习 Spring Framework 的重要组成部分 Spring Bean Scope（作用域）。你将了解它们是什么、如何工作以及何时使用。最后，你将对 Spring Bean Scope 有一个清晰的了解，从而帮助你构建更好的 Spring 应用程序。 Spring Bean 介绍 在 Spring Framework 的世界里，“Spring Bean” 是一个非常重要的术语。从本质上讲，Spring Bean 是由 Spring IoC（反转控制）容器实例化、组装和管理的对象。这些 Bean 是根据你提供给容器的配置元数据创建的，例如，以 XML 定义或源代码注解的形式。 Bean 可以看作是任何 Spring 应用程序的基本构件。它们是构成应用程序主干的对象，由 Spring IoC 容器管理。这些 Bean 是根据项目中提供的定义创建的，用于履行应用程序中的各种角色，如 service 类、数据访问对象 (DAO)、Spring MVC Controller 等对象，甚至是简单对象。 Spring Bean Scope 是什么 Spring Bean Scope（或换句话说，Bean 的作用域）决定了这些 Bean 在应用程序各种上下文中的生命周期和可见性。 Spring Bean 的 scope 定义了 Bean 存在的边界、与之绑定的上下文以及存活时间。简而言之，它定义了何时创建 Bean 的新实例，以及何时删除该特定实例。 Spring 提供多种 scope，例如： Singleton Prototype Request Session Application Websocket 每个 scope 都意味着不同的生命周期和它们定义的 Bean 的可见性。正确理解和使用这些 scope 对于构建稳健高效的 Spring 应用程序至关重要。 https://springdoc.cn/restclient-in-spring6/ Thu, 24 Aug 2023 19:32:12 +0800 https://springdoc.cn/restclient-in-spring6/ Spring Framework 6.1 M2 引入了 RestClient，一个新的同步HTTP客户端。顾名思义，RestClient 提供了 WebClient 的 fluent API和 RestTemplate 的基础架构。 14年前，当 RestTemplate 在 Spring Framework 3.0 中被引入时，我们很快发现在一个类似模板的类中暴露 HTTP 的所有功能会导致过多的重载方法。因此，在 Spring Framework 5 中，我们为响应式的 WebClient 使用了 fluent API。通过 RestClient，我们引入了一个 HTTP 客户端，它提供了类似于 WebClient 的API，并使用了 message converter、request factory、拦截器以及 RestTemplate 的其他底层组件。 创建 RestClient 你可以使用静态的create方法创建一个RestClient。你也可以使用RestClient::builder来获得一个具有更多选项的 builder，比如指定要使用的HTTP客户端，设置默认的URL、path 变量和 header，或者注册拦截器和初始化器（initializer）。 使用 RestClient::create(RestTemplate)，你可以使用现有 RestTemplate 的配置初始化 RestClient。 Retrieve 让我们创建一个 RestClient，用它来设置一个基本的 GET 请求，并使用 retrieve 以字符串形式获取网站的内容： RestClient restClient = RestClient.create(); String result = restClient.get() .uri("https://example.com") .retrieve() .body(String.class); System.out.println(result); 如果你对响应状态码和 header 感兴趣，而不仅仅是对响应内容感兴趣，你可以使用 toEntity 获取 ResponseEntity： https://springdoc.cn/spring-cloud-gateway-active-health-check/ Thu, 24 Aug 2023 19:24:52 +0800 https://springdoc.cn/spring-cloud-gateway-active-health-check/ 如今，应用程序被构建为小型独立上游服务的集合。这加快了开发速度，并使模块专注于特定职责，提高了质量。这是使用微服务方法的主要优势之一。然而，从一个服务跳转到另一个服务会增加额外的延迟，当服务没有响应时，这种延迟会显著增加。 如果你运行的是微服务，你需要防止上游服务在工作不正常时被调用。即使使用断路器（circuit breaker）模式，也会对响应时间造成影响。因此，有时最好主动检查上游服务，以验证它们是否在需要之前就已准备就绪。 健康检查是确定服务是否能够根据其状态作出正确响应、防止超时和错误的一种方法。 被动健康检查 在请求处理过程中进行。如果服务最终处于不健康状态，应用程序将返回失败，并标记端点不健康。这会增加额外的延迟。 主动健康检查 将在接收请求之前在后台检查并放弃不健康的服务。它不会增加额外的延迟。 最后但并非最不重要的一点是，这些功能可与断路器库结合使用，以便立即 fall back 到另一个 endpoint ，而不会受到首次失误的惩罚。 目标是通过使用负载均策略，将路由请求转发到健康的上游服务： 本文章分为两部分： “你需要的 Spring 功能” - 描述你需要哪些 Spring 功能来获得主动的健康检查。 “为你的服务注册端点”- 参考一些将一个或多个端点添加到路由中的方法。 1、你需要的 Spring 功能 Spring 的一些功能可以帮助你进行主动的健康检查： Spring Cloud Load Balancer（SLB）是客户端负载均衡器，可在不同上游服务端点之间均衡流量。它是 Spring Cloud 项目 的一部分，包含在 spring-cloud-commons 库中（参见 SLB文档）。 客户端服务发现功能可让客户端查找服务并与之通信，而无需硬编码主机名和端口。spring-cloud-commons 库中也包含该功能（参见 服务发现文档）。 Spring Cloud Gateway 为在 Spring 和 Java 之上构建API网关提供了一个库。它通过 LoadBalancerClientFilter / ReactiveLoadBalancerClientFilter 全局过滤器支持上述功能。在本文章中，你将看到使用这些全局过滤器的不同方法。 首先，让我们来了解其中的一些功能。 Spring Cloud Load Balancer filter Spring Cloud 中包含用于负载均衡的全局过滤器，可通过使用特殊的 URI 符号激活：lb://your-service-name。 spring: cloud: gateway: routes: - id: myRoute uri: lb://your-service-name predicates: - Path=/service/** 负载均衡器过滤器 ReactiveLoadBalancerClientFilter （用于响应式应用程序）将检测 URI 并将其替换为与 your-service-name 相关的可用端点。 https://springdoc.cn/jpa-records/ Thu, 24 Aug 2023 19:23:08 +0800 https://springdoc.cn/jpa-records/ 1、概览 在本教程中，我们将探讨如何在 JPA 中使用 Java Record，包括以下内容。 为什么 Record 不能作为 Entity 使用。 在 JPA 中使用 Record。 在 Spring Boot 应用中使用 Spring Data JPA 和 Record。 2、Record 和 Enttiy Record 是不可变的，用于存储数据。它们包含字段、全参数构造函数、getter、toString 和 equals/hashCode 方法。由于它们是不可变的，因此没有 setter。由于其语法简洁，在 Java 中经常被用作数据传输对象（DTO）。 Entity（实体）是映射到数据库表的类。它们用于表示数据库中的条目。它们的字段被映射到数据库表中的列。 2.1、Record 不能作为 Entity 实体由 JPA provider 处理。JPA provider 负责创建数据库表，将实体映射到表，并将实体持久化到数据库。在流行的 JPA provider（如 Hibernate）中，实体是使用代理来创建和管理的。 代理是在运行时生成并继承实体类的类。这些代理依赖于实体类的无参数构造函数和 setter。由于 Record 不具有这些，所以它们不能用作实体。 2.2、在 JPA 中使用 Record 的其他方法 由于在 Java 中使用 Record 的简便性和安全性，在 JPA 中以其他方式使用 Record 可能是有益的。 在 JPA中，我们可以通过以下方式使用 Record： 将查询结果转换为 Record。 使用 Record 作为DTO在各个层之间传输数据。 将实体转换为 Record。 3、项目设置 我们将使用 Spring Boot 创建一个使用 JPA 和 Spring Data JPA 的简单应用程序。然后，我们将了解在与数据库交互时使用 Record 的几种方法。 https://springdoc.cn/spring-quickstart/ Thu, 24 Aug 2023 19:10:32 +0800 https://springdoc.cn/spring-quickstart/ 本入门指南将会引导你如何从零开始建立一个 Spring 应用，并提供经典的“Hello World!”端点，可供任何浏览器都访问。 环境预备 你需要在本地安装好 Java™ 开发工具包（JDK），以及一个 IDE，如 IntelliJ IDEA、Spring Tools、Visual Studio Code 或 Eclipse。 第 1 步：创建新的 Spring Boot 项目 通过 start.springboot.io 来创建一个“web”项目。在“Dependencies”对话框中搜索并添加 “web”依赖项，如截图所示。点击“Generate”按钮，下载压缩包，并将其解压到电脑上的一个文件夹。 start.springboot.io 创建的项目包含 Spring Boot，这个框架使你不需要太多的代码或配置就可以让 Spring 在你的应用中工作。Spring Boot 是启动 Spring 项目的最快速和最流行的方式。 第 2 步：添加代码 在你的 IDE 中打开项目，找到 src/main/java/com/example/demo 文件夹中的 DemoApplication.java 文件。现在改变该文件的内容，添加下面代码中所示的额外方法和注解。你可以复制并粘贴该代码，或者手动输入该代码。 package com.example.demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController; @SpringBootApplication @RestController public class DemoApplication { public static void main(String[] args) { SpringApplication. https://springdoc.cn/docs/ Thu, 24 Aug 2023 14:02:52 +0800 https://springdoc.cn/docs/ 📖 文档列表 Spring Spring Boot Spring AI Spring Security Spring Data Spring Data Jdbc Spring Data Jpa Spring Data MongoDB Spring Data Redis Spring Cloud Spring Cloud Bus Spring Cloud Gateway Spring Cloud Kubernetes Spring Cloud Circuit Breaker Spring Cloud Config Spring Cloud OpenFeign Spring Authorization Server Spring Batch Spring Amqp TODO 🚫 版权声明 本站中的内容来源于 spring.io ，原始版权归属于 spring.io。本站内容由 springdoc.cn 进行翻译，整理。可供个人学习、研究，未经许可，不得进行任何转载、商用或与之相关的行为。 商标声明：Spring 是 Pivotal Software, Inc. 在美国以及其他国家的商标。 🔎 关注 微信公众号 论坛 Spring Boot 中文社区 https://springdoc.cn/about/ Thu, 24 Aug 2023 14:02:52 +0800 https://springdoc.cn/about/ 欢迎来到『spring 中文网』，这是由 Spring 爱好者共同维护的一个社区网站。我们提供了高品质的 Spring 框架中文文档， 包括 Spring、Spring Security、Spring Boot、Spring Data 等等，供开发者免费阅读，并且不定期更新。 同时也输出优质的原创技术博客和转载内容。旨在为广大开发者提供一个学习、交流和分享的平台，让大家能够更好地掌握和应用 Spring 相关技术，提高开发效率和质量。 如果你有任何关于 Spring 相关技术的问题、建议或合作意向，欢迎随时联系我们。 🍻 支持 我们提供的所有中文文档、教程和资讯均是 免费的，无须登录、无须关注。网站内容的维护和服务器都需要时间和金钱的支出，所以我们在页面上投放了一些广告，希望你能够理解。尽管如此，我们还是没有在访问量最高的中文文档页面中投放任何广告（失业了，迫不得已要恰饭）。 你如果觉得我们的内容对你有所帮助，你可以考虑小额捐赠，或者是点击页面上任何你 感兴趣 的广告。 微信 支付宝 感谢你对『spring 中文网』的支持，谢谢。 🔎 关注 微信公众号 论坛 Spring Boot 中文社区 QQ交流群 586178491 📩 联系 邮箱：kevinblandy.cn@gmail.com / 747692844@qq.com 微信：KevinBlandy