每日新聞摘要

Kotlin, Jetpack Compose, and an understanding of backend architecture are presented as core strategies for Android developers who want to remain relevant and command higher salaries. The piece argues that adopting Kotlin and the modern Compose UI toolkit streamlines development and aligns developers with current platform standards, while backend knowledge helps engineers contribute across the stack and communicate better with server teams. Together these skills increase employability and market value. The article also emphasizes a growth-oriented mindset: keep learning, follow platform trends, and integrate architectural thinking into app design. This approach positions developers for senior roles and cross-functional collaboration, and helps them adapt to evolving platform APIs, modern libraries, and industry demands. In short, combining language, UI toolkit, backend literacy, and a learning mindset is the recommended path for Android careers into 2025 and beyond.

文章提出 Kotlin、Jetpack Compose 与后端架构知识，作为 Android 开发者在 2025 年及以后保持竞争力并争取更高薪资的核心做法。採用 Kotlin 与 Compose 可提升开发效率、与平台标准接轨；了解后端架构有助于跨团队协作与系统化思考。文章强调持续学习、拓展技能组合，不应局限于旧 API 或单一专长；通过掌握语言、现代 UI 工具与架构思维，开发者能提升就业价值、胜任更资深或跨职能的角色，并更容易应对平台与行业的变化。

This article argues for automating Android development workflows by moving manual tasks—especially testing—into automated pipelines. It emphasizes establishing CI/CD processes that run builds and tests on each change so developers no longer rely on ad hoc local checks. The piece highlights code generation as a way to eliminate repetitive boilerplate, reduce human error, and accelerate implementation of common patterns. Combined automation and productivity tweaks can streamline feedback loops, increase confidence in releases, and free engineers to focus on higher‑value work. Rather than testing manually, the recommended approach is to design pipelines that validate functionality, run unit and integration checks, and gate merges. Overall the guidance centers on practical automation: improve developer efficiency and product quality by delegating routine verification and repetitive code tasks to CI/CD and generation tools.

本文主张通过自动化优化 Android 开发流程，重点是把手动测试交由 CI/CD 流水线执行，避免依赖零散的本地检查。文章强调建立能在每次变更时自动构建与测试的机制，从而缩短反馈周期并提升发布信心；同时建议使用代码生成来消除重复样板代码、减少人为错误并加快常见模式的实现。将这些自动化与效率技巧结合起来，可以让团队将时间放在更高价值的任务上，让例行验证和重复代码交给工具与流水线处理，从而整体提升产品质量与开发效率。

This article, Part 1 of a series, explains how Kotlin Multiplatform combined with Compose Multiplatform can be used to build configuration-driven user interfaces that let teams ship Android, iOS, and web applications in days. It argues that centralizing UI configuration and sharing Kotlin-based UI logic via Compose reduces cross-platform duplication, shortens development and release cycles, and improves maintainability and UX consistency. The post frames Compose Multiplatform as a compelling alternative to React Native and Flutter and presents the idea of an ultimate go-to-market stack to accelerate delivery. Focused on mastering configuration-driven UI patterns, the piece introduces practical rationale, suggested tooling and workflow considerations, and prepares readers for deeper implementation details in subsequent installments.

本文为系列的第一部分，介绍如何利用 Kotlin Multiplatform 与 Compose Multiplatform 构建以配置驱动的 UI，从而在数日内将 Android、iOS 与 Web 应用交付上线。文章认为，通过集中化的 UI 配置与共享 Kotlin 的 UI 逻辑，团队可以减少跨平台重复工作、缩短开发与发布周期，并提升可维护性与用户体验一致性。文中将 Compose Multiplatform 定位为一个可与 React Native 和 Flutter 竞争的替代方案，概述了加速交付的 GTM 技术栈与工作流建议，为后续章节的实施细节做好铺垫。

This guide explains how Android developers can use Kotlin’s async/await together with the Room persistence library to perform safe, non‑blocking local database operations. By moving DB work off the main thread and coordinating it with coroutine-based async/await patterns, apps can avoid blocking calls that cause UI jank and unresponsiveness. The article positions this approach as a practical way to integrate Room’s structured local storage with modern concurrency constructs, emphasizing safe concurrency practices when accessing and updating local data. The result is guidance aimed at helping developers build faster, more responsive Android applications through careful use of asynchronous operations and Room’s abstractions for persistent storage.

本文介绍了 Android 开发者如何将 Kotlin 的 async/await 与 Room 持久化库结合，进行安全、非阻塞的本地数据库操作。通过把数据库工作放到主线程之外并使用协程管理异步流程，可以避免阻塞调用导致的 UI 卡顿，从而提升应用的响应性。文章将这种方法作为实用指南，强调在访问和更新本地数据时应注意的并发安全要点，帮助开发者利用现代异步模式与 Room 的数据抽象构建更快速、更流畅的 Android 应用。

This comprehensive guide argues that building maintainable, scalable, and testable Android applications requires a solid architectural foundation. It presents the combination of the MVVM pattern with Clean Architecture principles as an approach to separate concerns, isolate business logic, and reduce coupling between layers. By using a layered, dependency‑rule‑oriented design, developers can make codebases easier to understand, modify, and test, which in turn supports long‑term project evolution. The guide highlights the motivations and benefits of such structures—clearer separation between UI and domain logic, improved ability to write automated tests for core rules, and greater capacity to scale as features expand—making architecture a practical tool for sustaining and evolving Android apps.

这篇综合性指南指出，要构建可维护、可扩展且易于测试的 Android 应用，必须建立坚实的架构基础。文章提出将 MVVM 模式与 Clean Architecture 原则结合的思路，通过分层与关注点分离来隔离业务逻辑、降低耦合，从而提高测试性与扩展性。内容集中讨论架构设计的动机与好处，帮助开发者在长期演进的项目中保持代码可读性与可修改性，并将架构视为改善测试流程和系统维护的实用工具。

This short piece introduces Kotlin Symbol Processing (KSP) as a modern alternative for compile-time code generation, emphasizing that it can double compilation speed and simplify the developer experience. Rather than continuing to struggle with annotation-processing workflows, KSP presents straightforward compile-time solutions that aim to make generated code handling faster and less cumbersome. The article highlights the key benefit — roughly a twofold build-speed improvement — and frames KSP as a practical way to reduce friction around annotations and generation tasks in Kotlin projects. Readers are encouraged to explore KSP as a performance-focused tool for streamlining build-time generation, maintaining that it addresses common pain points encountered with traditional annotation processing.

本文简要介绍了 Kotlin Symbol Processing（KSP），将其作为一种现代化的编译期代码生成替代方案，强调 KSP 可带来约 2 倍的编译速度提升并简化开发者体验。作者指出，与继续与注解处理流程纠缠不同，KSP 提供更直接的编译期解决办法，使生成代码的流程更快、更不繁琐。文章将 KSP 描述为一个侧重性能与便利性的实用工具，建议开发者考虑在 Kotlin 项目中采用，以缓解传统注解处理带来的常见痛点。

This beginner-focused article introduces animate*AsState, the core state-driven animation API in Jetpack Compose for handling single-property transitions. It explains why animate*AsState is useful for creating smooth, declarative animations tied to state changes and shows how it simplifies common tasks such as animating values when a state flips. The piece is Part 1 of a series and concentrates on simple transitions, offering conceptual clarity and practical examples to help developers replace manual, imperative animation code with concise, readable Compose patterns. By mastering animate*AsState, readers can achieve visually pleasing, predictable animations with minimal code and better integration into Compose's reactive model.

本文为系列第一篇，介绍 Jetpack Compose 中的 animate*AsState，这是一个以状态为驱动、用于实现单一属性动画（如数值或颜色变化）的核心 API。文章说明 animate*AsState 如何在状态变化时自动生成平滑过渡，使开发者能够以声明式、简洁的方式替代繁复的命令式动画代码。内容侧重概念讲解与实作示例，旨在帮助初学者快速掌握在 Compose 中创建可预测且美观的动画效果。

This article examines why Jetpack Compose 1.9.2 is a notable step forward compared to 1.8, arguing that the release resolves important developer pain points. It highlights improvements that go beyond incremental changes — from eliminating performance headaches to refining visual details like drop shadows — and explains how these refinements translate into a smoother, more reliable development experience. The piece frames 1.9.2 as the version Android developers have been waiting for, emphasizing practical benefits such as better rendering fidelity and fewer performance regressions. Rather than focusing on surface-level updates, the article presents 1.9.2 as a substantive evolution that positively impacts real-world app development and developer productivity.

本文探讨了为何 Jetpack Compose 1.9.2 相较于 1.8 是一次重要的升级，指出该版本解决了许多开发者关心的痛点，并在视觉呈现上有显著改进。文章从性能优化切入，延伸到渲染细节（例如投影阴影）的完善，说明这些改动如何带来更流畅、更可靠的开发体验。作者认为 1.9.2 不只是小幅更新，而是对真实项目开发和开发效率具有实质影响的演进，因此被视为许多 Android 开发者期待的发布。

This Medium article by Hasan Tunçay outlines an approach to integrating the Box2D v3 physics engine into a Kotlin Multiplatform project by leveraging JNI and native C interop. It frames the motivation for reusing a proven C/C++ physics library from Kotlin targets, and highlights general challenges and considerations when combining native and managed code—such as performance, portability, and maintenance trade-offs. The post aims to provide practical guidance for exposing native engine functionality to Kotlin modules, building and packaging native components, and handling cross-platform interoperability. The author includes the aphorism “Docendo discimus” (“by teaching, we learn”), underlining the intent to share concrete experience and lessons for developers tackling physics engine integration across platforms.

Hasan Tunçay 在 Medium 的文章介绍了如何将 Box2D v3 物理引擎集成到 Kotlin Multiplatform 项目中，借助 JNI 与原生 C 互通在多平台复用成熟的 C/C++ 引擎。文章概述了整合的动机、涉及的跨平台互操作性挑战，以及在性能、可移植性与维护之间的权衡与实践建议。作者引用了「Docendo discimus（教学即是学习）」一语，表明通过分享经验为需要在不同平台调用原生物理引擎的开发者提供参考。

Kotlin coroutines have streamlined asynchronous programming by providing a clean, structured approach, yet many developers still find error handling difficult. This article highlights why managing exceptions in coroutine contexts matters, focusing on failures that occur inside the launch {} builder. It emphasizes that while coroutines improve code organization and concurrency control, exceptions propagate differently than in synchronous code, and incorrect handling can lead to silent failures or unexpected application behavior. The piece encourages readers to learn how launch {} behaves with thrown exceptions, to recognize common pitfalls, and to apply proper strategies for observing, propagating, or containing coroutine failures so that asynchronous systems remain predictable and maintainable.

Kotlin 协程为异步编程带来更清晰的结构与控制，但错误处理仍是常见痛点。文章强调在协程上下文中，异常的传播与同步代码不同，尤其在使用 launch {} 时，失败可能不会如预期被观察或传递，从而导致应用出现隐性错误或不稳定行为。作者建议开发者理解 launch {} 的失败处理机制，识别常见陷阱，并采用合适策略来观察、传播或隔离协程中的错误，以使异步系统更可预期并便于维护。

This article demonstrates how to extend Koog-based Kotlin agents by implementing an ExecuteShellCommandTool that enables agents to run shell commands and use real execution feedback to improve code. It outlines the required tool anatomy—name, description, Args/Result classes, and an execute() method—and shows how the execute flow requests confirmation, runs the command, captures output and exit codes, and returns results to the LLM. Safety options include interactive confirmation or a Brave mode for automated approval. The CommandExecutor handles timeouts by preserving partial output and forcibly terminating overdue processes. Integrating the tool required minimal agent changes (including a BRAVE_MODE toggle and an enhanced “definition of done” prompt encouraging tests). Benchmarks show execution capability increased success from 50% to 56%. The next article will cover logging and tracing to improve visibility and iteration.

文章展示了如何为 Koog 框架扩展工具功能，以 ExecuteShellCommandTool 为例使代理具备运行 shell 命令并利用执行反馈改进代码的能力。说明了工具的要素：名称、描述、Args/Result 类别与 execute() 的实现流程——请求确认、执行命令、收集输出与退出码，并把信息传回给 LLM。为降低风险，提供交互式确认或可通过环境变量启用的 Brave 模式；执行器通过超时机制在保留尽可能多的输出后强制结束长时进程。将工具集成到代理只需少量代码变更（含 BRAVE_MODE 切换与增强的「完成定义」，鼓励写测试）。基准结果显示执行能力能提高成功率，下一步将聚焦日志与追踪以改善可视化和调优。

This roundup collects November Kotlin news and resources: Kotlin 2.3.0-RC has arrived, inviting users to explore new features before the stable release. Kotlin Multiplatform documentation now lives on kotlinlang.org with a toggle to switch between Language and Multiplatform views, improving navigation and clarity. The Kotlin team will host a week-long Reddit AMA where developers can ask about language design and tooling. Learning opportunities include a four-week Kotlin Multiplatform program (Nov 10–Dec 8), a December 3 livestream for Android developers transitioning to full‑stack KMP, and KotlinConf’26 announcements (20% Black Friday ticket discount and an imminent Call for Speakers deadline). Other items: an expanding Kotlin adoption guide series, a Ktor user survey, Exposed 1.0.0-rc-3 refinements, highlights of Google Summer of Code 2025 projects, and a Compose Multiplatform for web poll — plus curated links and YouTube highlights for further exploration.

本篇汇总了十一月的 Kotlin 要闻与资源：Kotlin 2.3.0-RC 已上线，欢迎开发者尝鲜并了解新功能；Kotlin Multiplatform 文档迁移到 kotlinlang.org，新增语言/多平台切换，阅读与查找更便利。社区活动涵盖一周的 JetBrains Reddit AMA、自 11 月 10 日开始的为期四周 KMP 学习营（至 12 月 8 日）、12 月 3 日面向 Android 开发者的实作直播，以及 KotlinConf’26 的黑五票券折扣与即将截止的征稿。其他亮点包括 Kotlin 采用指南系列、Ktor 年度问卷、Exposed 1.0.0-rc-3 的修整、Google Summer of Code 2025 项目展示，以及关于 Compose Multiplatform for web 的快速投票与多项延伸阅读与视频。

This issue highlights the general availability of Spring Framework 7.0, which brings support for Java 25 and Jakarta EE 11 while maintaining a Java 17 baseline, and introduces features like programmatic bean registration, core resilience enhancements, and stronger null safety. Immediate IntelliJ IDEA 2025.3 support is noted, and commentary points to modern Java library choices that reduce boilerplate. The roundup lists numerous Spring-related GA releases (Spring Data, Spring AI, Spring for GraphQL, Spring for Apache Kafka, Vault, REST Docs) and broader JVM ecosystem updates including Quarkus, Micronaut, Helidon, WildFly, Payara, Netflix components, and Elasticsearch. The newsletter also curates technical and engineering articles on container scaling, event-driven patterns, distributed graph storage, and personalized models, and closes with a Pick of the Week promoting Baeldung’s Black Friday All Access course sale.

本期重点报道 Spring Framework 7.0 的 GA 发布：支持 Java 25 与 Jakarta EE 11、维持 Java 17 基线，并带来程序化 bean 注册、核心弹性增强与更严格的 null 安全。文中同时提到 IntelliJ IDEA 2025.3 已立即提供支持，并引用讨论现代 Java 精简样板代码的文章。汇整了多项 Spring 生态及相关框架的新版本与发布（如 Spring Data、Spring AI、Spring for GraphQL、Kafka、Vault、REST Docs），以及 Quarkus、Micronaut、Helidon、WildFly、Payara、Netflix 组件和 Elasticsearch 的更新。技术与随笔板块推荐了关于容器扩展、事件重试、分布式图存储与个性化模型整合的文章，结尾推广 Baeldung 的黑五 All Access 课程优惠。

This article explains how Java SecureRandom interacts with Linux entropy sources and whether blocking is a practical concern. SecureRandom can use several algorithms (NativePRNG, NativePRNGBlocking, NativePRNGNonBlocking and others) chosen by JVM settings or explicit getInstance() calls; requesting a missing algorithm throws NoSuchAlgorithmException. Linux provides /dev/random (blocking) and /dev/urandom (non-blocking), but since kernel 5.19 the system gathers enough entropy after early boot so blocking is unlikely and /dev/urandom is considered safe for practical cryptographic use. The author also benchmarks NativePRNGBlocking vs NativePRNGNonBlocking with JMH, generating 20,000 samples of 256 bytes; both finish in about 95–96 ms, showing no meaningful performance difference. The conclusion: NativePRNGNonBlocking is sufficient for most applications on modern Linux.

本文讨论 Java SecureRandom 如何依赖 Linux 的熵源以及是否会因熵耗尽而阻塞。SecureRandom 的默认算法由 JVM、java.security 配置或 java.security.egd 决定，也可用 getInstance() 指定特定算法，若不存在则抛出 NoSuchAlgorithmException。Linux 提供 /dev/random（会阻塞）和 /dev/urandom（非阻塞），但自内核 5.19 起，除开机早期外系统可获得足够熵，因此阻塞已不太可能，/dev/urandom 的随机性亦足够实际使用。作者用 JMH 对 NativePRNGBlocking 与 NativePRNGNonBlocking 做了基准（20,000 个 256 字节样本），两者均约 95–96 ms，结论是非阻塞版本对大多数应用已足够。

JEP 452 adds a standardized Key Encapsulation Mechanism (KEM) API to Java 21, filling a gap in the Java Cryptography Architecture by providing a provider-neutral, single API for establishing shared symmetric keys using public-key cryptography. A KEM abstracts key pair generation, encapsulation (producing a shared secret and an encapsulation blob), and decapsulation (recovering the secret from the blob and private key), avoiding format and padding pitfalls and supporting both classical and post‑quantum algorithms. The JDK implementation includes RSA-KEM, ECIES, and DHKEM (RFC 9180), and providers can add others like Kyber. The tutorial shows encapsulation and decapsulation utility methods, a KemResult record to hold the shared key and encapsulation, and unit tests that verify matching secrets and that decapsulation fails with the wrong private key.

JEP 452 将 Key Encapsulation Mechanism (KEM) API 并入 Java 21，弥补 Java 加密架构中长期存在的空白，提供一个单一、与提供者中立的接口来通过公钥密码学安全地建立共享对称密钥。KEM 将密钥对生成、封装（发送方用接收方公钥产生共享密钥与封装 blob）和解封装（接收方用私钥与封装还原共享密钥）三者标准化，避免直接使用 Cipher 时的格式与填充问题，并支持传统与后量子算法。文章演示了封装/解封装的工具实现、KemResult 容器及单元测试，验证密钥一致性并确保错误私钥无法解封装。

Chicory is a JVM-native WebAssembly runtime implemented entirely in Java that loads .wasm binaries into the JVM, exposes exported functions as Java APIs, and avoids JNI or native dependencies. The tutorial shows a Maven quickstart: add the Chicory runtime dependency, compile a minimal add.wat to add.wasm (using wat2wasm), and run a JUnit 5 test that parses the module, instantiates it, and calls the exported add function. It then demonstrates imports by defining a Java HostFunction (double), registering it in a Store, instantiating the module through that store, and invoking an exported useDouble helper. The article explains value-type mapping—calls cross a long-only boundary (parameters as long, results as long[]), how to pass floating-point values and non-numeric data via linear memory, and common errors (unresolved imports at instantiation and missing exports at call time). Full code is available on GitHub.

本文介绍 Chicory：一个纯 Java 实现的 JVM 原生 WebAssembly 运行时，展示如何在 Maven 项目中快速上手并使用 JUnit 5 运行示例。步骤包括添加 Chicory 运行时依赖、使用 wat2wasm 将简单的 add.wat 编译为 add.wasm、通过 Parser 将二进制解析为模块并实例化以调用其 add 导出。接着演示如何在 Java 中定义 HostFunction（如 double）、将其注册到 Store 并通过该 Store 实例化模块以满足导入。文章还说明了值类型映射：调用跨越 long 边界，浮点需位级打包，非数值通过线性内存传递，并讨论了常见错误（实例化时未解析的导入与调用时缺失的导出）。完整代码托管于 GitHub。

This article explains three practical methods to discover which keystore a running JVM uses. First, the JAVA_HOME environment variable points to the Java installation where the default truststore (cacerts) is located under lib/security/cacerts, which is useful for manual tasks. Second, when keytool runs without an explicit keystore path, Java uses a user-specific keystore (typically ~/.keystore) in the user's home directory for private keys and certificates. Third, the most reliable approach is programmatic: use Java system properties such as System.getProperty("java.home"), System.getProperty("user.home"), and check System.getProperty("javax.net.ssl.trustStore") to construct and verify keystore paths at runtime. The article also notes that java.home (the running JVM) can differ from the JAVA_HOME environment variable on systems with multiple Java installs, and recommends the programmatic method for deployed applications.

文章介绍了三种查找 JVM keystore 的方法：首先，可通过 JAVA_HOME 环境变量快速定位到安装目录下的 lib/security/cacerts 来找到系统信任库；其次，若使用 keytool 未指定 keystore，会在用户主目录生成或使用 .keystore，通常用于存放个人私钥与证书；最后，推荐在运行时以程序方式读取 System.getProperty("java.home")、System.getProperty("user.home") 及 System.getProperty("javax.net.ssl.trustStore")，根据这些属性构建并验证 keystore 路径。这种程序化方式在多 Java 版本或部署环境中最为可靠，因为 java.home（运行时 JVM）可能与环境变量 JAVA_HOME 不同。

This tutorial introduces JUnit 5's Engine Test Kit, which runs Test Plans and collects statistics and detailed events. It uses a simple Display/Platform example with tests that succeed, fail, are disabled (skipped), and abort via failed assumptions. The guide shows how to verify that a chosen Test Engine (e.g., junit-jupiter) is discoverable and detects the test class, then how to execute the suite and assert high-level statistics (started, finished, succeeded, failed, skipped, aborted). It also demonstrates drilling down into Events to assert why a test aborted (abortedWithReason and message checks) or failed (finishedWithFailure and exception type), and mentions other assertion helpers like skippedWithReason and finishedSuccessfully. The piece concludes by noting the benefit of these checks for preventing regressions and verifying expected failure reasons.

本教程介绍了 JUnit 5 的 Engine Test Kit，说明如何运行测试计划并收集不同层次的统计和事件信息。以 Display/Platform 为例，包含成功、失败、被禁用（跳过）以及因假设不满足而中止的测试。演示先确认 junit-jupiter 或其他引擎可以被发现并识别测试类，随后执行测试并用 assertStatistics 验证启动、完成、成功、失败、跳过和中止的数量。进一步展示如何获取 Events，使用 abortedWithReason、finishedWithFailure 等断言来验证测试中止或失败的具体原因与异常类型，从而有助于防止回归并确认预期的失败原因。

IntelliJ IDEA can automatically add a newline at the end of files to improve consistency and avoid small problems in version control. You can enable a built-in On Save option (Editor > General > On Save) to ensure every saved file ends with a line break, or configure Code Style settings for language-specific formatting during reformat/save. For team projects, add insert_final_newline = true (and trim_trailing_whitespace = true) to a .editorconfig in the project root so all editors respect the rule. To avoid multiple blank lines at EOF, enable the Remove trailing blank lines at the end of the file option; combined with the line-break setting this guarantees exactly one final newline. These steps reduce unnecessary Git diffs, linter warnings, and merge issues while keeping files clean.

本文介绍了在 IntelliJ IDEA 中保证文件结尾换行的一些方法：可以启用 IDE 的 On Save 选项来在保存时自动添加换行，或通过 Code Style 的设置在重格式化或保存时应用结尾规则。对于团队协作，推荐在项目根目录添加 .editorconfig，并设置 insert_final_newline = true 与 trim_trailing_whitespace = true，让不同编辑器遵循相同标准。若出现文件末尾多余空行，可启用移除尾部空白行的选项，与插入单一换行配合，确保每个文件仅以一个换行符结尾，从而减少 Git 差异、警告和合并问题。

TermQuery is a core Elasticsearch primitive that performs exact, non-analyzed matches on fields, making it appropriate for structured data like keywords, booleans, numeric values, and identifiers. The article walks through practical examples: defining a users index and mappings, bulk-inserting documents, and composing multiple term filters inside a bool.filter to retrieve exact AND-style matches. It shows how to execute these queries directly with Query DSL, with the Elasticsearch Java Client (including unit-test examples), and via Spring Data Elasticsearch repositories, noting that repository methods produce equivalent term queries but with less control. The piece also demonstrates combining term filters with terms aggregations to count roles among active users, and includes configuration snippets for Java/Spring clients and beans, highlighting trade-offs between speed, cacheability, and scoring.

本文介绍了 Elasticsearch 的 TermQuery，用于对字段执行不经分析的精确匹配，适合标签、布尔、数值与 ID 等结构化数据。文章通过实例讲解：建立 users 索引与映射、批量插入文档，并在 bool.filter 中结合多个 term 查询以实现 AND 条件的过滤，从而获得快速且缓存友好的结果（但缺乏评分）。示例涵盖直接使用 Query DSL、使用 Elasticsearch Java Client（含单元测试）、以及通过 Spring Data Elasticsearch repository 的等价查询，并展示如何在聚合中先用 term 过滤再按 role.keyword 做 terms 聚合以统计活跃用户的角色分布。文中还给出 Java/Spring 客户端与 bean 的配置片段，并说明了适用场景与权衡。

This Medium article introduces FlowRow and FlowColumn in Jetpack Compose as flexible alternatives to the standard Row and Column. It explains how these components let children wrap onto new lines or columns, making layouts more adaptive to varying content sizes and screen widths. By using FlowRow/FlowColumn developers can build responsive interfaces that handle dynamic items—such as tags, chips, or variable-length content—without custom measurement or manual flow logic. The piece highlights practical benefits for Android UI design, including improved wrapping, spacing, and alignment control, and offers guidance to apply the APIs for more resilient, adaptive layouts in Compose-based apps.

本文在 Medium 上介绍了 Jetpack Compose 中的 FlowRow 与 FlowColumn，作为传统 Row 与 Column 的灵活替代。它们允许子元素在空间不足时自动换行或换列，使布局能根据内容大小与屏幕宽度动态调整，适用于标签、chips 或长度不一的列表项。文章强调这些组件能简化自定义测量与流式布局逻辑，改善间距与对齐控制，并提供实用建议，帮助开发者在 Compose 中构建更健壮、响应式的 UI。

This article examines Kotlin’s SharedFlow and the rationale behind its design choice not to store emitted values by default. It highlights SharedFlow’s strength for one-time events (for example, navigation actions) where delivering past events to newly started collectors would be undesirable. By not persisting values, SharedFlow avoids replaying stale events and helps ensure event handling remains timely and intentional. The piece frames this characteristic as a feature rather than a limitation, explaining that avoiding implicit state retention simplifies event-driven patterns in Android apps and reduces surprising behavior for subscribers. Overall, the article argues that SharedFlow’s non-storing semantics improve correctness and predictability when dealing with ephemeral UI events.

本文探讨了 Kotlin 的 SharedFlow 及其默认不存储发出值的设计理念。文章强调，SharedFlow 在处理一次性事件（如导航操作）时尤为合适，因为将过去事件回放给新启动的收集者通常是不期望的。通过不持久化值，SharedFlow 避免了回放过时事件，确保事件处理更为及时且有意图。作者将这种行为视为优点而非限制，认为避免隐含状态有助于简化事件驱动的开发模式，并减少订阅者遇到意外行为的可能性。总体而言，文章认为 SharedFlow 的不存储语义提高了处理临时 UI 事件时的正确性与可预测性。