每日新聞摘要

Hermes is an HTTP-centric message broker that runs on top of Apache Kafka, providing a lightweight interface for publishing and receiving messages without requiring clients to understand Kafka. Its architecture comprises Management (UI for groups, topics and subscriptions), Frontend (accepts publish requests) and Consumers (deliver messages to endpoints), and it depends on Kafka and Zookeeper. Allegro supplies Docker images and a Docker Compose example for quick testing. Topics are organized into groups and have metadata such as name, owner, Kafka ACK level and content type. Subscriptions define endpoints, delivery type, rate limits and in-flight limits and can replay retained messages. Messages are published via HTTP POST to /topics/{fully.qualified.name} (returning 202 and Hermes-Message-Id) or via a Java client; consumers receive POSTs to registered endpoints, with 2xx/4xx considered delivered and 5xx triggering retries. Hermes emphasizes reliability and easy scaling.

Hermes 是一个建立在 Apache Kafka 之上的 HTTP 中心化消息代理，允许客户端通过标准 HTTP 请求或 Hermes Java 客户端轻松发布和接收消息，无需了解底层消息基础设施。体系由 Management（用于管理群组、主题与订阅）、Frontend（接受发布请求）和 Consumers（将消息发送至订阅端点）等组件构成，并依赖 Kafka 与 Zookeeper。Allegro 提供 Docker 镜像与 Docker Compose 示例以便快速测试。主题（topics）归属群组，拥有名称、所有者、Kafka ACK 等配置；订阅（subscriptions）定义接收端点、投递类型、速率限制与在途消息上限，并能回放保留期内的消息。发布到 /topics/{完整主题名} 的 HTTP POST 会返回 202 与 Hermes-Message-Id，消费者通过注册的 HTTP POST 接收消息，2xx/4xx 视作已投递，5xx 则可能重试。Hermes 强调可靠性与易扩展性。

JEP 519 finalizes Compact Object Headers for Java 25, building on JEP 450 from Java 24 to make a compact 64-bit (8‑byte) object header the standard layout on 64‑bit platforms. The compact layout subsumes a compressed class pointer into the mark word, reduces class pointer encoding to about 22 bits, and preserves identity hash, GC age, tags and locking bits. Locking paths are simplified (legacy stack-locking removed), GC forwarding uses self‑forwarding bits and a 42‑bit forwarding address, and compressed class pointers are required (limiting class count but adequate for typical apps). Enabling flags moved from experimental to product; benefits include ~10–20% lower live-data memory for object‑heavy workloads, improved cache locality and reduced GC frequency/latency. Benchmarks show notable heap and CPU gains (e.g., SPECjbb2015 results). Risks include header‑bit exhaustion, JVMCI incompatibility, and the need for extensive testing.

JEP 519 在 Java 25 中将 Compact Object Headers 正式化，基于 Java 24 的 JEP 450，将对象头在 64 位平台上缩减到 64 位（8 字节）。该方案把压缩类指针编码并入 mark word，保留哈希码、GC 年龄与锁位等信息，并将类指针编码降至约 22 位以节省空间。锁机制与 GC 转发做了相应调整（移除旧的 stack-locking 路径，使用自我转发位和低 42 位地址），且要求启用压缩类指针。对小对象密集的应用，常驻数据内存可减少约 10–20%，提升缓存利用率并降低 GC 负载。风险包括标头位不足、JVMCI 不兼容及需大量测试验证。

This tutorial extends a Dapr + PubSub ride-hailing example by adding Dapr Workflows to orchestrate complex, long-running, and durable processes. It explains the durable execution model—automatic state persistence, workflow replay, and centralized retry policies—so multi-step flows (validate driver, calculate fare, notify passenger, wait for confirmation) can resume after failures without losing progress. Workflows are implemented in Spring Boot as code: deterministic workflow logic calls activities (the only place to perform external I/O) and uses the workflow context to wait for events or raise events. The guide shows starting workflows via REST or PubSub events, creating activities for validation, fare calculation, and notification, and testing happy and unhappy paths with Testcontainers. It also covers retry policies and running the app in a managed Dapr environment using Diagrid Catalyst.

本文在先前的 Dapr + PubSub 用例上引入 Dapr Workflows，用于编排复杂且需持久化的多步骤长时程流程。介绍耐久执行的要点：步骤后自动持久化状态、重启时重放工作流代码（使用已持久化的结果避免重复执行）以及统一的重试策略，使如验证司机、计算车费、通知乘客与等待确认等流程能在失败或重启后无缝继续。示例使用 Spring Boot 以程式码定义工作流与活动，活动负责外部 I/O，工作流保持决定性。文章还展示透过 REST 或 PubSub 发起工作流、使用 Testcontainers 测试正常与异常情境、定义重试策略，以及在 Diagrid Catalyst 托管的 Dapr 环境中运行应用的流程。

The java.io.IOException: Invalid keystore format error occurs when Java attempts to read a file that doesn’t match the expected keystore structure. Common causes include incorrect file extensions (for example a PEM or PKCS#12 file renamed to .jks), using the wrong KeyStore type in code (e.g., loading a PKCS#12 file as JKS), corruption during transfer or storage, and build tools or differing JDK/keytool versions that modify binary files. Diagnose the problem with keytool -list -v to reproduce the error and see stack traces, openssl pkcs12 -info to detect PKCS#12 containers, and by checking build resource filtering. Fixes include using the correct KeyStore.getInstance("PKCS12") or "JKS" in code, converting formats with keytool -importkeystore, ensuring binary-safe transfers, and re-exporting or recreating corrupted keystores. Maintaining consistent Java environments and disabling text filtering prevents many issues.

java.io.IOException: Invalid keystore format 错误表明 Java 正在读取的文件并非其期望的密钥库格式。常见原因有错误的文件扩展名（例如将 PEM 或 PKCS#12 改为 .jks）、代码中使用了错误的 KeyStore 类型、文件在传输或存储过程中损坏，以及 Maven/Gradle 等构建工具或不同的 JDK/keytool 版本对二进制文件的处理造成改变。排查可用 keytool -list -v 复现并查看堆栈信息，使用 openssl pkcs12 -info 确认是否为 PKCS#12，检查构建配置以关闭资源文本过滤。解决办法包括在代码中使用正确的 KeyStore.getInstance("PKCS12") 或 "JKS"、用 keytool -importkeystore 转换格式、确保以二进制模式传输或重新导出密钥库，并保持一致的 Java 环境以避免兼容性问题。

This article explains how to stop a Java Scanner reading from System.in when input is complete. It shows that Scanner blocks waiting for input and that pressing Return ends only the current line, not the stream. Two recommended approaches are using the OS end-of-file (EOF) marker (CTRL+D on Unix/Mac, CTRL+Z on Windows) or implementing a sentinel value such as 'exit' to signal completion. The tutorial also warns against closing a Scanner on System.in because it closes the underlying stream, and advises avoiding System.exit(0) unless necessary. Common mistakes are highlighted: using == to compare strings or checking for null, which don't work for content equality. Examples include while loops with hasNextLine(), a do-while sentinel loop, and EOF handling. The article concludes that EOF and sentinel methods are most effective, with sentinel values often being more user-friendly.

本文介绍了在 Java 中如何在输入完成后终止从 System.in 读取的 Scanner。文章指出，Scanner 会阻塞等待输入，按回车只结束当前行而不是输入流的结尾。常见且有效的两种做法是使用操作系统的 EOF（Unix/Mac 上为 CTRL+D，Windows 上为 CTRL+Z）或定义哨兵值（例如 'exit'）由用户显式结束。作者提醒不要随意关闭用于 System.in 的 Scanner，因为这会关闭底层输入流，同时建议尽量避免滥用 System.exit(0)。还强调了常见错误，例如用 == 比较字符串或检测 null。示例包括 hasNextLine() 循环、do-while 与哨兵模式，结论认为 EOF 与哨兵方法最可靠，哨兵通常更友好。

MapStruct creates concrete mapper implementations during compilation, but those generated classes are plain Java classes unless configured for Spring. If Spring cannot detect or register the generated MapperImpl classes, dependency injection fails with NoSuchBeanDefinitionException and the application may not start. To fix this, configure mappers with @Mapper(componentModel = "spring") so MapStruct adds @Component to implementations, enable annotation processing in your build tool (add mapstruct-processor to maven-compiler-plugin or Gradle annotationProcessor), and turn on annotation processing in your IDE. Also ensure mapper interfaces are in packages scanned by Spring and resolve Lombok/MapStruct processor ordering to avoid incomplete model classes. Proper component model, build and IDE settings, and correct package scanning ensure MapStruct mappers are produced and registered as Spring beans, preventing runtime bean-creation errors.

MapStruct 在编译时生成映射器（mapper）的具体实现，但生成的类默认不带 Spring 注解，导致 Spring 无法将其识别为 Bean，从而在注入时抛出 NoSuchBeanDefinitionException 并可能导致应用无法启动。解决方法包括在 @Mapper 中设置 componentModel = "spring"，使生成的实现带上 @Component；在 Maven 或 Gradle 中启用 annotation processing（将 mapstruct-processor 加入编译器处理路径或 annotationProcessor 依赖）；并在 IDE 中开启註解处理。同时要确认 mapper 所在包被 Spring 扫描并处理 Lombok 与 MapStruct 的处理器执行顺序，防止模型类不完整或缺失 getter/setter。正确的组件模型、构建与 IDE 配置以及包扫描设置可确保 MapStruct 的 mapper 被生成并注册为 Spring bean，避免运行时的 Bean 创建错误。

This issue of Java Weekly highlights key platform and ecosystem changes: JDK 26 officially drops the java.applet package, prompting final build-path checks. Spring Data’s AOT-generated repositories (Part 2) are explored, showing how build-time code generation for JPA, JDBC and MongoDB improves startup and enables integration with Project Leyden. The roundup also points to notable JEP previews (Lazy Constants, Structured Concurrency), Spring Tools 5 updates, and articles on migration patterns, pagination, testing, and HttpClient TLS enhancements. Multiple releases are recommended for upgrade, including Spring Cloud 2025.1.0 (Oakwood), Quarkus 3.30.0, Micronaut Core milestone releases, Hibernate Search, Elasticsearch, Grails and Conductor. Technical essays cover event-sourcing patterns (Consumers vs Processors), GraphRAG vs RAG, visitor-pattern revisits, and open-source upgrade strategies. The pick of the week is a Snyk live workshop on the OWASP Top 10 in the age of AI.

本期概览 Java 平台与社区动态：JDK 26 正式废弃 java.applet 包，建议开发者最后检查构建路径；Spring Data AOT 仓库（第二部分）解析如何通过构建时为 JPA、JDBC 与 Mongo 生成代码以优化启动并支持 Project Leyden。文中还推荐了多篇相关内容，包括 JEP 预览（Lazy Constants、Structured Concurrency）、Spring Tools 5 的准备与改进、以及关于分页、测试、TLS 支持等实务指南。同时列出若干建议升级的版本：Spring Cloud 2025.1.0 (Oakwood)、Quarkus 3.30.0、Micronaut Core、Hibernate Search、Elasticsearch、Grails 与 Conductor。技术与随想栏目讨论事件溯源中的消费者/处理器分离、GraphRAG 与 RAG 的差异，以及开源升级策略；本周精选为 Snyk 关于 AI 时代 OWASP Top 10 的公开工作坊。

This tutorial shows how to draw high-quality circles in Java Swing by using Graphics2D and the Java2D shape APIs. It starts with a JPanel that overrides paintComponent and demonstrates using Ellipse2D for a circle, then explains dynamic sizing and centering while accounting for stroke thickness to avoid clipping. The guide covers rendering hints—antialiasing, stroke control, and rendering quality—to improve smoothness and sub-pixel accuracy, and illustrates transforms for testing. For very small icons it recommends offscreen rendering: supersampled rendering (draw larger and scale down) for maximum smoothness, and hardware-compatible BufferedImage for runtime efficiency. It also suggests caching rendered images or combining both techniques to balance visual quality and performance when drawing many small circular indicators.

本文讲解如何在 Java Swing 中绘制高质量圆形：通过继承 JPanel 并重写 paintComponent，使用 Ellipse2D 创建宽高相等的形状来表示圆，结合 Graphics2D 的绘制与填充。示例展示根据窗口尺寸动态计算直径并以中心点定位，同时考虑笔触延伸以避免裁切。为获得更细腻的效果，启用抗锯齿、纯描边控制和高质量渲染提示以改善曲线与子像素准确度。针对 12–24 像素的小图标，推荐离屏渲染：可用超采样（先绘制为 2× 或 3× 大小再缩小）以获得最佳平滑度，或使用硬件兼容的透明 BufferedImage 以提高绘制效率，并通过缓存复用图像在大量指示器场景下保持 UI 响应。

In this tutorial Haidar Ali demonstrates how to automate creation of Debian .deb packages from Java builds using jdeb. It explains DEB anatomy — debian-binary, control.tar.*, and data.tar.* — and introduces jdeb, a self-contained library (Maven plugin and Ant task) that builds .deb files cross-platform without Debian tools. The article shows Maven configuration bound to the package phase, how to define control metadata and dataSet mappers, and gives a simple "simple-cal" example that packages a fat JAR into /opt, a launcher into /usr/bin, and creates runtime directories. It covers running mvn clean package, inspecting the resulting .deb with dpkg, and installing/testing on a Debian-based system. The Ant equivalent is also provided, showing the DebTask usage and local classpath setup. The piece concludes that jdeb simplifies producing .deb artifacts for Java projects and is available on Maven Central.

本文展示如何使用 jdeb 将 Java 构建自动打包为 Debian .deb。文章先介绍 .deb 的三大组成（debian-binary、control.tar.*、data.tar.*），再说明 jdeb 的特性：在 Maven 和 Ant 中提供任务、支持跨平台执行且自包含，无需依赖 UNIX 工具。以 simple-cal 为例，示范如何在 pom.xml 或 build.xml 中配置 control 目录、dataSet 与 mapper，把 fat JAR 放到 /opt、把启动脚本放到 /usr/bin，并创建运行时目录。还展示了 mvn clean package 的输出、使用 dpkg 查看与安装包的流程，以及 Ant 版的 DebTask 配置。结论是 jdeb 可简化 Java 项目的 .deb 打包与发布，且可从 Maven Central 获取。

This article explains why Hibernate throws the SyntaxException "token '*', no viable alternative at input" and how to fix it. The error occurs because HQL operates on entities and their properties, not on database tables and columns, so the SQL '*' wildcard is not valid. The post demonstrates the exception using a simple Person entity and an HQL query containing SELECT * FROM Person, which causes the SyntaxException. The recommended solution is to select the entity itself, for example SELECT p FROM Person p, or to omit the SELECT clause entirely and use FROM Person. The article includes a unit test example showing the failure and a corrected test that persists a Person and retrieves it with valid HQL.

本文解释了为何会出现 SyntaxException "token '*', no viable alternative at input"，并通过示例说明如何复现与修正。问题在于 HQL 操作的是实体和属性，而不是数据库表与列，因此 SQL 中表示所有列的 '*' 在 HQL 中无效。文章用一个 Person 实体和包含 SELECT * 的 HQL 查询重现异常，然后展示正确做法：使用实体别名（SELECT p FROM Person p）或直接用 FROM Person 来省略 SELECT，从而正确获取实体列表，并附上单元测试示例展示错误与修正。

This article explains how to convert EBCDIC-encoded data to ASCII in Java, covering differences between EBCDIC and ASCII and the practical steps needed to bridge legacy mainframe data with modern systems. It shows decoding EBCDIC byte sequences into Java's internal Unicode Strings using Charset.forName with EBCDIC code pages such as Cp037, then re-encoding that String to ASCII or UTF-8 using StandardCharsets. Examples include decoding a hard-coded byte array, a step-by-step conversion pipeline that reads EBCDIC bytes into a String and obtains US_ASCII bytes, and a file-based example using FileInputStream to read an input.ebc file. For large files the article recommends streaming with InputStreamReader and OutputStreamWriter, or using CharsetDecoder/CharsetEncoder for finer control and performance. The main takeaways are selecting the correct EBCDIC code page, decoding to Unicode, and re-encoding to the target charset to make legacy data readable and portable.

本文介绍了如何在 Java 中将 EBCDIC 编码的数据转换为 ASCII：首先说明 EBCDIC 与 ASCII 的差异，然后示范用 Charset.forName（例如 Cp037）将 EBCDIC 字节解码为 Java 的 Unicode 字符串，再使用 StandardCharsets.US_ASCII 或 UTF-8 重新编码以便现代系统读取。文章给出小型字节数组解码、逐步的字节→字符串→ASCII 转换示例，以及用 FileInputStream 读取 input.ebc 并转换输出的完整文件示例。对于大型文件，建议使用 InputStreamReader/OutputStreamWriter 串流处理或 CharsetDecoder/CharsetEncoder 以获得更好的性能与控制。核心在于选对 EBCDIC 代码页、将字节正确解码为 Unicode，然后再编码为目标字符集以实现历史数据的可读性与可移植性。

This article explains how to make file resources available to a Quarkus application compiled as a GraalVM native image. Because GraalVM does not automatically include classpath resources in the native executable, you must explicitly list the files to be bundled. The piece demonstrates three approaches: placing static public assets in META-INF/resources (automatically exposed as web content); declaring glob patterns in application.properties via quarkus.native.resources.includes to include specific files from src/main/resources; and using a resource-config.json placed under src/main/resources/META-INF/native-image/<group-id>/<artifact-id> for more advanced patterns. It shows a simple readResource method using ClassLoader.getResourceAsStream, how to expose file contents via REST endpoints, and notes that JUnit tests run in the JVM but you should build and run the native executable (mvn -Pnative) to verify resources in the actual native image.

本文介绍了如何在使用 GraalVM 构建的 Quarkus 原生镜像中访问文件资源。由于原生镜像不会自动把 classpath 资源包含进可执行文件，开发者需要显式声明要打包的资源。文章演示三种方式：将公开静态资源放在 META-INF/resources 以供 Web 访问；在 application.properties 中通过 quarkus.native.resources.includes 指定 glob 模式包含 src/main/resources 下的文件；以及在 META-INF/native-image/<group-id>/<artifact-id>/ 下添加 resource-config.json 来支持更复杂的匹配规则。文中还给出了使用 ClassLoader.getResourceAsStream 读取资源并通过 REST 端点暴露的示例，并建议通过 mvn -Pnative 构建并运行原生可执行文件来验证资源可用性。

By 2026 three cross-platform frameworks dominate: Kotlin Multiplatform (KMP), Flutter, and React Native. KMP is mature, excels at sharing business logic across Android, iOS, desktop, web and backend, compiles to native for fastest cold starts, best on-device ML integration, and offers low energy use—ideal for enterprise, AI-driven and logic-heavy apps. Flutter, backed by Google, provides pixel-perfect, consistent UIs using its Impeller 2 engine, excels at 120Hz animation and GPU-heavy graphics, and supports AI UI generation—best for consumer apps and rich visual experiences. React Native benefits from a huge JavaScript/TypeScript talent pool and modernization (Fabric, TurboModules, React 19) for improved performance and faster time-to-market, fitting web-oriented teams and MVPs. Choose based on performance needs, UI fidelity, team skillset, budget and long-term roadmap rather than popularity alone.

到 2026 年，Kotlin Multiplatform (KMP)、Flutter 与 React Native 成为跨平台开发的三大主流。KMP 趋于成熟，擅长在移动、桌面、Web 与后端之间共享业务逻辑，编译为原生代码带来最快的冷启动、良好的设备端机器学习整合与较低的能耗，适合企业级与逻辑密集型应用。Flutter 在视觉一致性与动画性能上领先，借助 Impeller 2 引擎支持 120Hz 动画与 GPU 密集任务，适合消费类产品或对视觉要求高的应用。React Native 受益于庞大的 JavaScript/TypeScript 人才库与 Fabric、TurboModules 等现代化改进，便于快速迭代与推出 MVP。最终应根据性能、UI 要求、团队技能和长期路线做出选择。

As of 2026, Kotlin Multiplatform (KMP), Flutter, and React Native are the dominant cross-platform choices, each optimized for different priorities. KMP excels at compiling shared business logic to native binaries, giving the fastest cold starts, best battery and memory efficiency, and strong on-device ML integration—ideal for enterprise, AI-driven, and logic-heavy apps. Flutter, powered by the Impeller 2 engine and Dart 3.5, delivers the most consistent, pixel-perfect UI across surfaces and superior GPU/animation performance, suited for consumer apps and high-fidelity interfaces. React Native, modernized with Fabric, TurboModules and a new JSI bridge, benefits from vast JS/TS talent and rapid MVP development, though initial load and runtime remain JS-dependent. Cost and maintenance trade-offs differ: RN offers lower initial hiring cost, Flutter balances medium initial with lower maintenance, and KMP has higher upfront native expertise needs but lower long-term maintenance. Choose based on performance needs, UI demands, team skills, and long-term platform alignment.

截至 2026 年，Kotlin Multiplatform、Flutter 和 React Native 各有定位。KMP 以将共享业务逻辑编译为原生二进制见长，启动速度最快、功耗与内存效率最高，且与设备端 ML 整合良好，适用于企业级和 AI 驱动的复杂应用。Flutter 借助 Impeller 2 和 Dart 提供统一且高保真的 UI 表现，尤其擅长 GPU 密集型动画与 120Hz 交互，适合消费者产品与可视化仪表盘。React Native 在新架构（Fabric、TurboModules）与 JSI 桥接下性能显著提升，结合广泛的 JavaScript/TypeScript 人才与 Expo 工具，适合想快速迭代或沿用 Web 技能的团队。最终应根据性能要求、UI 重视度、团队构成和长期维护成本来决定。

Author Hadyan Kholish Prasetio provides a step-by-step tutorial for installing Android Studio and using Kotlin to create a simple “Hello Android” application. The article starts by directing readers to the official Android Studio download page (developer.android.com/studio) to get the stable release and install the IDE. After installation, the guide explains configuring Android Studio for Kotlin development, creating a new project, and adding minimal code and UI to display a “Hello Android” message. It’s aimed at beginners who need a concise, practical walkthrough to set up the development environment and run their first app on an emulator or device. The tutorial emphasizes using official tools and links to the Android developer site to ensure readers download the correct release. It assumes no prior Kotlin experience and keeps explanations practical.

Hadyan Kholish Prasetio 的教程说明如何安装 Android Studio 并使用 Kotlin 构建一个简单的“Hello Android”应用。文章先引导读者前往官方下载页面 (developer.android.com/studio) 获取稳定版本并完成安装，随后说明在 Android Studio 中配置 Kotlin 开发环境、建立新项目，并加入最基本的代码和界面以显示“Hello Android”信息。该教程面向初学者，侧重实用的环境搭建和首次运行应用，并通过官方链接确保下载到正确的发布版本。

This entry, titled "How mocking works under the hood?", is authored by Marcin Moskala and targets Kotlin developers. The only available excerpt greets the audience with "Hello Kotliners!" and instructs readers to continue reading the full piece on Medium. The title indicates the article's focus is explaining how mocking operates beneath the surface, but the provided text does not include the substantive content or technical details. To read the full explanation and examples, the reader is directed to the Medium link. The excerpt functions as an introduction and pointer rather than a self-contained article, so interested readers must follow the link to access Marcin Moskala's full discussion on mocking internals.

这篇由 Marcin Moskala 撰写的文章，标题为「模拟在底层如何工作？」，目标读者为 Kotlin 开发者。当前可见的摘录非常简短，仅包含对 Kotlin 社区的问候「Hello Kotliners!」并提示“Continue reading on Medium »”以获取完整内容。标题表明文章意在解释 mocking 的底层机制，但提供的片段并不包含具体技术说明或示例；它作为介绍并引导读者前往 Medium 阅读完整文章，想了解详细内容的人需访问链接查看全文。

Kumarsamy highlights how using Kotlin Coroutines with structured concurrency can make Android apps smoother, faster, and more responsive. Structured concurrency organizes asynchronous work into clear scopes tied to component lifecycles, which simplifies task management, cancellation, and error handling. By keeping background operations predictable and bounded, coroutines reduce the risk of leaks and inconsistent states, improving UI responsiveness and overall performance. The article is a concise prompt to adopt coroutine-based patterns so background work is better coordinated with app components; readers are directed to the full Medium post for implementation examples and practical guidance on applying these patterns in real projects.

作者指出，借助 Kotlin Coroutines 并采用结构化并发，可以使 Android 应用变得更顺畅、更快速和更具响应性。结构化并发将异步任务组织到清晰的作用域中并绑定到组件生命周期，从而简化任务管理、取消与错误处理，降低资源泄漏和状态不一致的风险。这种方式让后台工作更可预测、更可控，从而提升界面响应和整体性能。文章篇幅简洁，并引导读者到 Medium 查看详细实现示例和实践建议。

This article explains how to convert pixelated, sampled strokes into polished, professional signatures by combining Bézier curve mathematics with simulated ink physics, implemented in Kotlin Multiplatform. It outlines the core steps: sampling input points, constructing control points and Bézier interpolations to smooth the trajectory, and applying a physics-inspired model that uses velocity and pressure to modulate stroke width and ink flow. The approach balances mathematical derivation and practical engineering to preserve signature characteristics while reducing artifacts from raw touch or bitmap input. Implementing the solution in Kotlin Multiplatform enables the same logic to be reused across platforms, aiming to deliver accurate, performant digital ink suitable for signature input and other handwriting applications.

本文示范如何将触控或点阵数据产生的颗粒化笔迹，通过贝塞尔曲线与拟真物理模拟，转成专业的签名向量。作者说明以采样点建立曲线控制点、利用贝塞尔插值平滑轨迹，并加入速度与压力相关的墨迹物理模型以模拟笔尖宽度与流量变化。整体做法兼顾数学推导与工程实现，并以 Kotlin Multiplatform 实现跨平台代码复用，兼顾准确度与性能，适用于签名输入与数字墨迹应用。

This article presents a thorough examination of Android's ViewModel, ViewModelStore, and the ActivityThread, with the primary aim of explaining how ViewModel instances are managed and how they survive configuration changes. It focuses on internals and runtime relationships so readers can understand why ViewModels can outlive activity recreation triggered by rotations or other configuration updates. The piece clarifies the roles of the store and the thread that coordinate lifecycle-driven retention and cleanup, and highlights practical implications for app state management. Rather than high-level patterns alone, the article aims to demystify the underlying mechanisms and interactions that determine ViewModel lifetime, helping developers make predictable architecture and memory-safety decisions when relying on ViewModel for surviving configuration changes.

本文对 Android 的 ViewModel、ViewModelStore 与 ActivityThread 进行了完整且深入的解析，核心在于说明 ViewModel 实例如何被创建、管理与回收，以及它们如何在配置变更（如屏幕旋转）导致 Activity 重建时仍然得以存活。文章着重揭示这些组件之间的运行时关系与保留行为，讨论这些内部机制对状态保持和内存管理的实际影响，帮助开发者理解为何 ViewModel 能在配置变更时保持状态，从而做出更稳健的架构与资源管理选择。

This article explains how to use hidden R8 artifacts — full-r8-config.txt and the whyareyoukeeping reports — to go beyond stack traces when diagnosing build size and minification problems. It shows how to extract and read the full-r8-config to see what rules and inputs R8 actually applied, and how to use whyareyoukeeping output to find which code, resources or libraries are being retained and why. The piece outlines practical steps for tracing unexpected kept classes or methods, identifying configuration mistakes, and reducing “build bloat” by removing or tightening keep rules. It also covers strategies to reproduce minification bugs, interpret mapping files, and iterate on rules until the app is both smaller and functionally correct, enabling precise fixes for excessive output and broken transformations.

本文说明如何利用 R8 的隐藏产物──full-r8-config.txt 与 whyareyoukeeping 报告──超越堆栈追踪诊断构建臃肿与混淆问题。文章示范如何提取并阅读 full-r8-config.txt，以了解 R8 实际应用的规则与输入，并使用 whyareyoukeeping 找出被保留的类、方法或资源及其原因。作者列出实务步骤追踪意外被保留的项、修正配置错误并收紧 keep 规则以减少 build bloat，同时提供重现混淆缺陷、解析映射文件与逐步调整规则的策略，让开发者能精确定位并修复过量输出与错误转换的根源。

This crash course introduces Kotlin's Flow API as a modern, coroutine-friendly solution for asynchronous programming on Android. The article positions Flow as the go-to tool for handling asynchronous operations and reactive data streams, emphasizing its concise integration with Kotlin coroutines. Readers can expect a compact primer that explains why developers adopt Flow for cleaner, coroutine-aware async code, how it fits into Android development patterns, and what benefits it brings compared with more verbose callback-based approaches. The piece aims to provide practical insight into Flow's role in modern applications and to equip readers with an understanding of its core purpose and typical usage scenarios, helping them decide when and how to adopt Flow in their projects.

本文以快速入门的角度介绍 Kotlin 的 Flow API，强调它作为现代 Android 应用处理中异步操作的常用工具。文章指出 Flow 与 Kotlin coroutine 的良好配合，使得异步代码更为简练且易于控制，特别适合用于反应式数据流的场景。读者可藉由此篇得到对 Flow 目标与典型使用情境的概览，了解其如何比传统的回调方式带来更清晰的结构，并据此判断在项目中何时采用 Flow 以提升代码可维护性和一致性。

This short best-practice article by Dmitry Protsenko on Level Up Coding focuses on two practical areas in Spring Data JPA: properly handling transactions and writing manual queries without relying on JPA "magic." It highlights how transactional misconfigurations or implicit JPA behavior can lead to subtle bugs, and encourages developers to use clear, explicit queries and transaction boundaries to improve predictability and maintainability. The piece positions these recommendations as pragmatic practices to avoid surprises in production systems, emphasizing clarity over implicit framework behavior. Readers are invited to follow the article for concrete tips and examples on making Spring Data JPA code more robust by reducing reliance on hidden conventions and preferring explicit, testable query logic.

本文由 Dmitry Protsenko 在 Level Up Coding 发布，聚焦 Spring Data JPA 的两项实务建议：正确处理事务和撰写不依赖 JPA 魔术的手写查询。文章指出，隐式的 JPA 行为或事务配置问题可能引发难以发现的缺陷，建议开发者使用明确的查询语句与清晰的事务边界，以提高代码的可预测性和可维护性。总体上主张以清晰、可测试的实现取代框架的隐式约定，从而在生产环境中减少意外和提高稳定性。

snapshotFlow is a Jetpack Compose utility that converts observed Compose snapshot state reads into a Kotlin Flow, emitting values whenever that state changes. This bridge between Compose’s snapshot system and coroutines/Flow lets you collect and react to state changes outside of composable functions, making it easier to run side-effects, apply debounce logic, or feed paginated data pipelines. Because snapshotFlow emits based on snapshot read dependencies, it helps you capture only meaningful changes and combine Flow operators (for example debounce or distinctUntilChanged) to control emission frequency and downstream behavior. The referenced article outlines real use cases, example snippets, and best practices for integrating snapshotFlow into Compose apps so state-driven effects are lifecycle-aware, predictable, and easier to manage.

snapshotFlow 是 Jetpack Compose 的一个工具，将对 Compose snapshot 状态的读取转换为 Kotlin Flow，当被观察的状态发生变化时会发出相应的值。它将 Compose 的状态系统与协程/Flow 连接起来，使得在 composable 之外收集状态变化并触发副作用变得更简单，便于实现去抖、分页等功能。由于 snapshotFlow 根据 snapshot 的读取依赖来决定何时发射，配合 Flow 操作符（如 debounce、distinctUntilChanged）可以有效控制事件发射频率与下游处理。文章介绍了真实用例、示例代码和最佳实践，幫助在 Compose 应用中更可预测且符合生命周期地管理状态驱动的效果。

Many Kotlin users who adopt modern mocking libraries such as Mokkery face a recurring obstacle: Kotlin makes classes and members final by default, making it hard to mock real production classes. In this article Mohab Erabi explains the motivation and design behind a Kotlin compiler plugin he built to address that limitation. Instead of changing source APIs, the plugin modifies declarations at compile time so classes and members can be mocked by existing tools. The post outlines why the problem matters for testing, the high-level approach of using a compiler plugin to transform declarations, and the practical benefits of integrating that plugin into typical mocking workflows. It also discusses challenges encountered and the overall payoff for unit testing without altering production code.

作者指出，使用现代 mocking 工具（如 Mokkery）的开发者在对真实生产类进行 mock 时，会遇到 Kotlin 将类与成员默认设为 final 的问题，导致测试受限。为了解决该问题，他实现了一个 Kotlin 编译器插件，在编译阶段对声明进行转换，使类与成员在不改变源 API 的情况下可被 mock。文章介绍了该做法的动机、插件的设计思路与实现考量，以及与现有 mocking 流程的整合效果，并讨论了遇到的挑战与实践收益，从而在不修改生产代码的前提下提升单元测试的可行性与便利性。

In this short Medium post, AndroidLeakTool recounts encountering a production memory leak and resolving it in two minutes by using a faster approach than the Android Studio Profiler. The piece contrasts the quick resolution with the much longer debugging time that would have been required had the profiler been used, and emphasizes the practical benefit of alternative diagnostic tools in production scenarios. While the article is brief, its core message is that choosing the right tooling and method can drastically reduce investigation time for real-world memory issues. Readers are given a concise account of the problem and outcome, with an implicit recommendation to consider specialized tools when tracing production leaks.

这篇由 AndroidLeakTool 在 Medium 发布的短文，讲述了作者在生产环境遇到内存泄漏并通过比 Android Studio Profiler 更迅速的方法在两分钟内修复的经历。文章通过对比强调了合适工具对排查生产问题的效率提升，说明在真实场景中选择专用或替代诊断工具可以显著缩短故障定位时间。内容虽简短，但传递出关键讯息：正确的工具和方法能够将耗时数小时的分析缩短为几分钟。

This article is a comprehensive beginner's guide to mastering layouts in Jetpack Compose, aimed at developers transitioning from XML-based UIs. It frames Compose as the modern approach for Android interface development and walks readers through essential layout primitives (such as Row, Column, and Box), the role of Modifiers, alignment and measurement concepts, and how these pieces interact to build responsive layouts. The guide emphasizes practical, step-by-step examples and migration advice to help developers convert existing XML layouts into Compose equivalents while improving maintainability and performance. It also highlights common pitfalls and best practices for arranging composables effectively, enabling readers to adopt Compose confidently and design flexible, idiomatic UI components.

本文为初学者提供一份完整的 Jetpack Compose 布局指南，面向从 XML 迁移到 Compose 的开发者，解释其优势与基本理念。文章介绍关键布局组件（如 Row、Column、Box）、Modifier 的使用、对齐和测量的核心概念，并说明这些要素如何协同构建响应式界面。通过逐步示例和迁移建议，示范如何将现有 XML 布局转为 Compose 实现，并提出常见问题与优化技巧，帮助读者快速掌握 Compose，创建可维护且灵活的 UI 组件。

This article argues against memorizing Kotlin's 'in' and 'out' keywords in isolation and instead presents a single, simple mental model to reason about variance. It explains the concept using concrete examples and diagrams so readers can see how types behave in practice, and it packages the key points into an interview-ready cheat sheet for quick review. The goal is to make variance intuitive and actionable, reducing reliance on rules to be memorized and increasing understanding through visualization and hands-on examples. The piece is aimed at developers preparing for interviews or seeking a clearer, more durable grasp of Kotlin's type variance.

文章主张不再机械记忆 Kotlin 的 in 与 out，而是采用一个简单且一致的心智模型来理解变异性。作者通过真实代码示例与示意图展示类型在不同场景下的行为，并整理出一份面试级的速查表，方便快速回顾和实战应用。核心目的在于用直观和可操作的方式，让开发者把抽象的类型变异性转化为容易理解且可在面试或日常编码中运用的知识。

Naufal Fajar Imani presents a personal account of learning to implement Android 12's Splash Screen API, with particular attention to using Animated Vector Drawable (AVD). The post is framed as the author's learning experience rather than a formal tutorial, and it emphasizes that the Android 12 update makes handling splash screens easier for developers. The author signals an intention to describe how he approached implementation and to share his impressions of the API change and AVD's role in that process. Readers are directed to the Medium article for the full write-up and any detailed examples or practical notes the author provides.

作者 Naufal Fajar Imani 在 Medium 上以个人视角记录他实现 Android 12 Splash Screen API 的学习经验，并在标题中提到使用 Animated Vector Drawable（AVD）。文章强调 Android 12 的更新让处理启动屏的流程更简单，内容以作者的实践感受和观察为主，而非标准教程。想了解完整实现细节或作者的示例与步骤，请继续阅读原文以获得完整说明。

The piece describes how many companies, including the author’s, have become more serious about complying with security standards and are turning to Android Mobile Device Management (MDM) as a tool to enforce those policies. Framed as a “little customized government,” Android MDM lets organizations configure devices, push policies, manage apps, and take remote actions to protect corporate data. While MDM helps standardize and strengthen security across fleets of devices, it also centralizes control over users’ phones and tablets, creating tensions around privacy, personal use, and employee autonomy. The article highlights the practical benefits of MDM for compliance and risk reduction while urging awareness of the implications of giving employers deep management capabilities over mobile endpoints.

文章指出，包括作者所在公司在内的许多企业为遵循安全标准，正越来越多地采用 Android 的移动设备管理（MDM）。作者将 MDM 比喻为“小型定制政府”，说明它能够帮助企业配置设备、下发策略、管理应用并执行远程操作以保护公司数据。MDM 在提升合规性和降低风险方面有明显优势，但也使企业掌握大量设备控制权，从而带来对员工隐私与个人使用自由的影响。文章提醒在强化安全与合规的同时，应权衡对用户自主性和隐私的影响。