每日新聞摘要

Kotlin Weekly #490 (21 December 2025) summarizes recent Kotlin ecosystem news: Kotlin 2.3.0 was released just before year-end, and JetBrains published practical migration resources including guidance for migrating Jetpack Compose apps to Kotlin Multiplatform and an adoption playbook for Java-centric teams. Kotlin DataFrame 1.0.0-Beta4 and migration notes are highlighted, and KotlinConf’25 case studies from major companies are showcased. Featured articles cover sqlx4k (a Kotlin Native PostgreSQL driver via Rust FFI), a comparison arguing Ktor may suit modern lightweight backends better than Spring, observability for Kotlin AI agents, an AI-driven KMP mobile app builder, and dependency analysis of the Java/Kotlin ecosystem. The issue also lists sponsored tooling (CI analytics), videos on Koin, Compose PDF rendering, and coroutine scopes, plus libraries like Cloudy, CodeContext, and kMMIO.

Kotlin Weekly 第490期（2025-12-21）汇总 Kotlin 生态最新要闻：Kotlin 2.3.0 在年底前发布，JetBrains 提供针对将 Jetpack Compose 应用迁移到 Kotlin Multiplatform 的指南，并发布面向工程师与管理者的 Kotlin 采纳总览；同时包含 Kotlin DataFrame 1.0.0-Beta4 的迁移说明。KotlinConf’25 展示了 AWS、Google、Meta、Uber、Duolingo 等品牌的实践案例。精选文章介绍 sqlx4k（通过 Rust FFI 的 Kotlin Native PostgreSQL 驱动）、论 Ktor 可能优于 Spring 的理由、为 Kotlin AI agents 增加可观测性、以 KMP 构建 AI 驱动移动应用的架构与经验，以及 Java/Kotlin 生态的依赖性分析。期刊还列出赞助工具、教学视频与新库推荐。

This Medium article by Prashant Verma, titled "Writing Custom Gradle Plugins for Android," examines the need to extend standard build.gradle configurations by implementing custom Gradle plugins for Android projects. It highlights situations where a plain build.gradle file does not provide sufficient modularity, reuse, or automation for complex builds, and presents the concept of encapsulating build logic into reusable plugins. The piece emphasizes motivations such as reducing duplication across modules, centralizing conventions, and streamlining project configuration. While concise, the article positions custom Gradle plugins as a practical solution for teams seeking cleaner, more maintainable Android build processes and points readers toward further details and examples on Medium.

本文由 Prashant Verma 在 Medium 发布，标题为《为 Android 编写自定义 Gradle 插件》，讨论在标准 build.gradle 无法满足项目需求时，如何通过自定义 Gradle 插件来扩展构建功能。文章指出，将构建逻辑封装为可复用的插件，可提升模块化、减少跨模块重复配置、统一项目约定并简化构建流程。作者阐述了采用自定义插件的动机与好处，并引导读者到 Medium 上查看更详细的示例与说明。

This article explains the three Kotlin keywords—inline, noinline, and crossinline—that control how higher-order function parameters are compiled and executed. Declaring a function inline asks the compiler to substitute the function body at call sites, which can reduce lambda allocation and call overhead. Use noinline on specific lambda parameters when you must prevent their inlining (for example, to store them or pass them around). Use crossinline when you want a parameter to be inlined but must forbid non-local returns from that lambda, ensuring control flow remains local to the lambda. The piece outlines practical scenarios and trade-offs so developers can choose the correct modifier based on performance, semantics, and use of returns in lambda expressions.

本文介绍 Kotlin 中控制高阶函数行为的三个关键字：inline、noinline 与 crossinline。inline 会让编译器在调用点展开函数体，从而减少 lambda 的分配和调用开销；当某些 lambda 需要被存储或传递，应该对这些参数使用 noinline，以避免内联；如果希望参数内联但必须禁止 lambda 中的非本地 return（即从外层函数直接返回），则使用 crossinline。文章通过实例与权衡说明，帮助开发者在性能、语义和返回行为之间做出合适选择。

This article presents the micro-interaction pattern of using Android Quick Settings tiles to provide instant input through so-called “Ghost Inputs.” The pattern focuses on surfacing small, context-specific input mechanisms without taking over the screen, allowing users to complete brief tasks quickly and with minimal disruption. The piece explains why Quick Settings tiles are a suitable surface for such micro-interactions, how Ghost Inputs can reduce friction compared with full-screen dialogs, and what trade-offs to consider when designing them (for example, balancing visibility, discoverability, and privacy). Practical guidance highlights aligning the interaction with platform conventions and respecting users’ screen real estate to deliver fast, unobtrusive input experiences.

文章介绍了一种微交互模式：通过 Android 快速设置磁贴（Quick Settings tiles）实现即时输入，称为“幽灵输入”。该模式旨在在不占用整个屏幕的前提下，让用户快速完成简短任务，降低操作摩擦。文章解释了快速设置磁贴为何适合承载此类微交互、幽灵输入相较于全屏对话的优势，以及设计时应权衡的要点，如可见性、可发现性和隐私保护。实践建议包括遵循平台习惯并尊重用户屏幕空间，以提供快速且不侵入的输入体验。

This practical guide explains how to discover devices on the same Wi‑Fi network in Android using mDNS (NSD). It introduces the fundamentals of multicast DNS service discovery, outlines the steps to register and discover network services, and summarizes required runtime permissions and lifecycle handling for reliable discovery. The article highlights Android 14 API changes that affect network discovery behavior and permission models, and shows how to adapt implementations to remain compatible. Readers are given troubleshooting tips, common pitfalls to avoid, and testing recommendations for local networks. The guide is implementation-oriented, intended for Android developers who need reliable device discovery on LANs, and emphasizes practical code considerations, permission updates, and strategies to verify and debug service visibility across devices on the same Wi‑Fi.

本文为实务指南，说明如何在 Android 中使用 mDNS（NSD）在相同 Wi‑Fi 网络上发现设备。文章介绍 multicast DNS 的基本概念、服务注册与发现流程，并概述需要的运行时权限与生命周期管理以维持发现的可靠性。同时指出 Android 14 的 API 变更如何影响网络发现行为与权限模型，并提供相应的调整与兼容性建议。对需要在本地局域网中实现设备发现的开发者，文章强调实作要点、常见陷阱与调试与测试建议，帮助验证服务在相同 Wi‑Fi 下的可见性与可访问性。

This developer guide explains how to detect and fix memory leaks in Jetpack Compose. It emphasizes the role of effect handlers and lifecycle-aware coding patterns to prevent unintended retention of objects, and recommends adopting best practices to manage resources within composables. The article also highlights diagnostic and inspection tools—most notably LeakCanary—to help locate leaks during development and testing. Aimed at Compose developers, the guide combines conceptual advice with practical tooling suggestions so teams can both reduce leak risk and streamline debugging when leaks occur.

本指南面向开发者，讲解如何在 Jetpack Compose 中检测与修复内存泄漏。文章强调通过 effect handlers 和符合生命周期的编码模式避免对象被意外持有，并建议采用一系列最佳实践来管理 composable 内的资源。指南还推荐使用诊断工具（如 LeakCanary）在开发与测试阶段定位泄漏，帮助团队降低泄漏风险并提高调试效率。

Jlama is an inference engine designed to run pre-trained large language models locally within Java/Maven projects, avoiding external APIs. The article explains how to add the jlama-native and jlama-core dependencies, enable Java 21 preview features (such as the Vector API) via JVM flags, and choose among integration options: jlama-cli for interactive experimentation, jlama-net to expose REST/OpenAI-compatible endpoints, and jlama-native to embed inference directly in code. A code example demonstrates downloading a model from Hugging Face using Downloader.huggingFaceModel, loading it with ModelSupport.loadModel (showing DType.F32 and DType.I8 choices), and invoking the generator builder to set session, prompt, ntokens, and temperature. The tutorial concludes that these steps let developers quickly experiment with models, prompts, and generation settings to integrate AI features into Java applications.

本文介绍了 Jlama，说明如何在基于 Maven 的 Java 项目中本地运行预训练大型语言模型以实现推理。文章首先说明在 pom.xml 中添加 jlama-native 与 jlama-core 依赖，并指出需通过 JVM 参数启用 Java 21 preview（例如 Vector API）以取得最佳效能。接着介绍三种集成方式：jlama-cli 用于快速试验与交互、jlama-net 可将 Jlama 部署为 OpenAI 相容的 REST 服务、jlama-native 可直接在代码中嵌入推理。示例演示使用 Downloader 从 Hugging Face 获取模型，使用 ModelSupport.loadModel 指定 DType.F32 或 DType.I8 载入模型，並通过 generateBuilder 設定 session、prompt、ntokens 与 temperature 执行生成。结论是，按照本文步骤即可在本地快速实验不同模型与生成配置，将 AI 功能整合到 Java 应用。

This article explains why and how to detach and reattach entities in a Spring JPA application. It builds a simple example with a User entity, a JpaRepository, and a UserDataService that creates users and activates them. After saving a new user, the repository is extended with a DetachableRepository and a DetachableRepositoryImpl that calls EntityManager.detach to remove the entity from the persistence context, preventing Hibernate’s dirty-checking from automatically flushing changes. To persist later updates, the example reattaches the entity by loading it again inside a @Transactional activateUser method (no explicit save needed) so the transaction will persist the change. The article also shows tests demonstrating that detached entities are not updated until reattached, and that activation only occurs when external verification succeeds. Alternatives such as EntityManager.clear or disabling Open-Session-in-View are noted.

本文介绍在 Spring JPA 应用中为何以及如何分离（detach）和重新附加（attach）实体。示例包含 User 实体、继承 JpaRepository 的 UserRepository、以及负责建立与激活用户的 UserDataService：在 createUser 保存新用户后调用 repository.detach(savedUser) 来将实体从持久化上下文移除，从而避免 Hibernate 的脏检查带来的自动更新。要保存后续变更，可在 activateUser 上使用 @Transactional，并通过 findById 重新加载实体并修改 activated 字段，无需显式调用 save，事务结束时变更会被持久化。文章还提供了仓库与服务层的测试用例，验证分离后实体不会被自动更新，且只有在外部验证通过时才会激活用户，同时提到可用 EntityManager.clear 或禁用 Open-Session-in-View 作为替代方案。

This article compares two Jackson-based methods for mapping POJOs to MongoDB documents in Java: MongoJack and bson4jackson. It explains BSON-specific types (ObjectId, Date, Decimal128) and the inefficiency of serializing POJOs to JSON strings before converting to MongoDB Documents. MongoJack supplies a high-level API—JacksonMongoCollection plus @ObjectId—to transparently handle serialization and simplify CRUD operations, demonstrated with a ProductService and Flapdoodle in-memory tests. bson4jackson extends Jackson with a BsonFactory to serialize directly to binary BSON; a BsonProductMapper implements toBytes/fromBytes/toDocument/fromDocument using RawBsonDocument and BsonDocumentCodec, with tests validating round-trip integrity. The article concludes MongoJack favors developer productivity and minimal boilerplate, while bson4jackson provides finer control and better integration with existing Jackson configurations; performance differences are generally small, so choose based on flexibility and integration needs.

本文比较了两种基于 Jackson 的 Java POJO 与 MongoDB Document 映射方案：MongoJack 与 bson4jackson。文章说明了 BSON 特有类型（如 ObjectId、Date、Decimal128）以及将 POJO 先序列化为 JSON 字符串再转换为 Document 的低效问题，并以 Product 类示例展示依赖与代码。MongoJack 提供 JacksonMongoCollection 与 @ObjectId 等高层 API，可透明地序列化 POJO 并简化 CRUD，示例中使用 Flapdoodle 进行内存数据库测试；bson4jackson 则通过 BsonFactory 直接生成二进制 BSON，BsonProductMapper 实现 toBytes/fromBytes/toDocument/fromDocument，并用 RawBsonDocument 与 BsonDocumentCodec 完成 Document 与 BSON 的互转与回测。结论为 MongoJack 强调开发便利与减少样板代码，bson4jackson 在序列化控制与与现有 Jackson 配置整合方面更灵活，性能差异通常较小，选择应依据整合与可定制性需求。

Project Reactor and Spring WebFlux stream large binary payloads as Flux<DataBuffer> for backpressure and low memory usage, but some APIs require the entire payload as a byte[] wrapped in Mono<byte[]>. The recommended approach aggregates the chunked Flux into one DataBuffer using DataBufferUtils.join(), which handles releasing the source chunks, then maps the resulting Mono<DataBuffer> to a byte[] (e.g., via DataBuffer.read or DataBufferUtils.toByteArray()). The final aggregated DataBuffer must be explicitly released (for example in a try-finally or doFinally) to avoid pool exhaustion. The article provides a concise utility method demonstrating this pattern and a JUnit test using DefaultDataBufferFactory to validate reconstruction of the original byte content from chunked buffers.

Project Reactor 与 Spring WebFlux 在处理大体量二进制数据时，通常以 Flux<DataBuffer> 分块流式传输，以支持背压并降低内存占用。但某些场景需要一次性完整的 byte[]（例如计算哈希、调用阻塞 API 或整体反序列化）。文章提出两步策略：先用 DataBufferUtils.join() 将 Flux 聚合为 Mono<DataBuffer>（此方法会释放来源片段），再将聚合后的 DataBuffer 转为 byte[]，并在转换后显式释放最终缓冲区以避免池耗尽。示例代码和 JUnit 测试展示了这一可靠、非阻塞的转换流程。

This article explains how MapStruct handles null values during object mapping and demonstrates multiple techniques with examples. It introduces simple source and target models (Order and Payment DTOs) and a PaymentMapper used by Order mappers. One approach uses @AfterMapping to post-process the generated target and set default properties such as empty lists or placeholder strings. Another approach leverages @Mapping annotations with defaultValue and defaultExpression to instruct the generated code to initialize properties when the source is null. The article also covers nullValueCheckStrategy: the default ON_IMPLICIT_CONVERSIONS adds checks only for direct mappings or conversions, whereas ALWAYS enforces null checks for every property. Sample generated implementations illustrate the behavioral differences and configuration flexibility.

本文介绍在 MapStruct 中处理映射空值的多种方法，示例使用 Order、Payment 及其 DTO。首先展示 PaymentMapper 作为基础，然后用 @AfterMapping 在映射完成后对目标对象填充空集合或默认字符串。接着说明通过 @Mapping 的 defaultValue 与 defaultExpression 在生成代码中直接指定当来源为 null 时要使用的默认值或实例。最后讨论 nullValueCheckStrategy：默认的 ON_IMPLICIT_CONVERSIONS 仅对直接映射或类型转换时添加 null 检查，而设置为 ALWAYS 则对每个属性都执行 null 检查。示例生成的实现代码清晰展示了这些配置的差别与灵活性。

The article surveys Kotlin's function capabilities, moving beyond basic syntax to examine how lambdas, higher-order functions, runtime reflection, and KFunction shape Kotlin's functional programming model. It outlines the differences between standard lambda expressions and named function references, explains how KFunction exposes metadata and invocation mechanics at runtime, and shows how reflection enables introspection of parameters, return types, and annotations. The author also discusses practical trade-offs—such as performance and type-safety considerations—when using advanced function constructs, and offers guidance for applying these features in real-world code. It highlights common patterns and offers suggestions for balancing readability with powerful but more complex function features, helping developers bridge the gap between elementary usage and deeper runtime understanding.

本文从标准 lambda 出发，延伸到反射与 KFunction 的机制，说明它们如何构成 Kotlin 的函数式编程引擎。作者解析函数与高阶函数的使用场景、运行时检视（reflection）如何揭示函数结构，以及 KFunction 在类型与调用层的角色。文章还讨论实现与性能考量，并提供在日常开发中应用这些进阶概念的建议与常见模式，帮助读者从基础迈向对函数在运行时行为與设计权衡的更深入掌握。

Kotlin's anonymous functions are distinct from lambdas in ways that materially affect control flow and type clarity. One key difference is return behavior: anonymous functions perform local returns, avoiding the non-local returns that lambdas can trigger and thus making the enclosing function's control flow more predictable. Declaring parameter and return types explicitly for anonymous functions further reduces ambiguity, aids the compiler, and improves code readability and robustness. The practical guidance is to prefer lambdas for concise, inline cases, but opt for anonymous functions when you require local returns or a clear type contract. Understanding and applying these nuances helps prevent subtle bugs during refactoring and makes Kotlin code easier to reason about and maintain.

本文阐述 Kotlin 中匿名函数与 lambda 的关键差异，重点在返回行为与显式类型对代码可预测性和稳健性的影响。匿名函数采用本地返回，避免 lambda 可能引起的非本地返回，从而使控制流程更加明确；同时显式声明参数与返回类型能减少类型推断的模糊，提高可读性与可维护性。实务建议是在需要本地返回或清晰类型契约时选用匿名函数，而在追求简洁时使用 lambda。理解并运用这些细节能减少重构时的意外和难察觉的错误，使 Kotlin 代码更可靠、更易维护。

This article focuses on accelerating Gradle build times by leveraging three complementary strategies: caching, parallel execution, and incremental builds. Caching preserves build outputs so subsequent runs can reuse prior results instead of recomputing everything, reducing waste. Parallel execution lets Gradle run independent tasks concurrently to make better use of multi-core machines. Incremental builds limit work to only the modules or tasks affected by recent changes, avoiding full rebuilds. Together, these approaches shorten feedback loops, improve developer productivity, and make continuous integration pipelines faster and more efficient. The piece frames fast builds not as a convenience but as a multiplier of productivity, and outlines why adopting these techniques is a practical investment for teams that rely on frequent builds.

本文围绕使用缓存、并行执行和增量构建三种策略来加快 Gradle 构建时间展开。缓存保存之前的构建产出，使后续运行可以重用结果而无需全部重算，从而减少浪费；并行执行允许 Gradle 同时运行相互独立的任务，更好地利用多核机器；增量构建只处理最近变更的模块或任务，避免整量重建。综合应用这些方法能缩短反馈周期、提升开发效率，并加速持续集成流水线。文章将快速构建视为提高团队生产力的重要手段，建议作为值得投入的实践。

This article presents a step-by-step guide to integrating Spotless into a large Jetpack Compose project. Spotless is a Gradle plugin that enforces consistent code formatting across a codebase without depending on individual IDE settings. The guide describes configuring Spotless within the Gradle build, applying formatting rules consistently across modules, and ensuring formatting is reproducible for all contributors. By centralizing formatting in the build system, teams can avoid editor-specific differences, reduce style-related merge conflicts, and maintain a uniform code style across a multi-module Compose application. It emphasizes reproducibility and team-wide consistency without relying on personal editor configurations.

本文以逐步指南的形式介绍如何在大型 Jetpack Compose 项目中整合 Spotless。Spotless 是一个 Gradle 插件，能在项目层面强制一致的代码格式，而不是依赖每个开发者的 IDE 设置。文章聚焦于在 Gradle 构建中配置 Spotless、在各模块间统一格式规则，并确保所有贡献者能重现相同的格式化结果。通过将格式化集中到构建系统，团队可避免编辑器差异带来的风格不一致，减少与风格相关的合并冲突，并在多模块的 Compose 应用中维持统一的代码风格。