Daily Digest

每日新聞摘要

2026年03月29日

今日總結

內容會跟隨語言切換。

📝 今日焦點：Kotlin Weekly 第504 期整合生態與實用資源，宣告 Dokka 2.2.0、KotlinConf'26，並聚焦 Mutflow、Process Over Magic、Process Watcher、Koog 與多項函式庫、影片與課程，並邀稿感謝 JetBrains 支持。 🏗 架構設計：示範 ARCore 與 Sceneform 的沉浸式實作，說明 Supabase 到推播的事件串接、動態 SSL pinning 的整合重點，並介紹以 OkHttp Authenticator 與 Mutex 統一管理 token 的攔截器方案以降低競爭與冗餘。 ✅ 測試與品質：提出以使用者為中心的崩潰處理以保留或還原重要狀態並提升信任，並強調將協程實作設計為可測試與可觀察的生產級模式。 🚀 語言演進：說明 KMP 逐步遷移策略，釐清 Kotlin 物件初始化（主、次建構子與 init）與繼承使用時的設計與測試要點。

📝 Today's highlights: Kotlin Weekly #504 aggregates ecosystem updates including Dokka 2.2.0, KotlinConf'26, Mutflow, Process Over Magic, Process Watcher, Koog, plus new libraries, videos, sponsored reports, Compose course, cheat-sheets, and community resources. 🏗 Architecture: Practical guides cover ARCore+Sceneform AR implementation, Supabase-triggered push integration, dynamic SSL pinning walkthroughs, and an OkHttp Authenticator plus Mutex pattern for token lifecycle management, with deployment and device-testing notes. ✅ Testing & quality: Emphasizes user-centered crash handling to preserve state and trust, and presents production-ready coroutine patterns for structured concurrency, cancellation, resource management, observability, testing, and debugging. 🚀 Language evolution: Covers incremental KMP migration strategies, Kotlin object initialization patterns (constructors and init), and inheritance guidance for maintainable language-level designs and best practices.

Kotlin Weekly #504

Kotlin Weekly 作者：發布：03-29 09:14

Kotlin Weekly #504

Dokka 2.2.0 is out and KotlinConf’26 (May 20–22, Munich) features workshops, talks and a conversation with Josh Long about Kotlin, Spring and AI on the JVM.

重點摘要

Dokka 2.2.0 released with a full changelog available.

KotlinConf’26 in Munich (May 20–22) offers workshops on KMP, AI, backend and more.

Notable articles and tools: Mutflow (single-compile mutation testing), Process Watcher for CI OOMs, and a Koog-based Deep Research Agent.

Kotlin Weekly #504 (29 March 2026) highlights recent Kotlin ecosystem updates: Dokka 2.2.0 release; KotlinConf'26 in Munich (May 20–22) with workshops on KMP, AI, backend and a conversation with Josh Long about Kotlin+Spring and AI on the JVM. Featured articles include Mutflow (a K2 compiler plugin for single-compile mutation testing), an AI-assisted workflow 'Process Over Magic', Process Watcher (a GitHub Action to diagnose CI OOMs by monitoring RSS, heap and GC), and building a Deep Research Agent with Koog. Videos cover SDK design lessons, experimental Explicit Backing Fields in Kotlin 2.3, and Kotlin 2.3.20 updates. Sponsored items include RevenueCat’s State of Subscription Apps report, Compose cohort pricing and a cheat-sheet. New libraries announced include acli, kstats, SVG to Compose converters, and WebAuthn Kotlin MPP components. The issue invites contributions and thanks JetBrains for support.

Kotlin Weekly 第504期

Dokka 2.2.0 发布；KotlinConf’26（5 月 20–22 日，慕尼黑）含 KMP、AI、后端等工作坊，并有与 Josh Long 的访谈。

重點摘要

Dokka 2.2.0 正式发布，完整更新列表已公布。

KotlinConf’26（5/20–22，慕尼黑）提供多场实践工作坊与议程。

重点文章与工具：Mutflow（单次编译的突变测试）、Process Watcher（CI OOM 诊断）、用 Koog 构建深度研究代理。

Kotlin Weekly 第504期（2026-03-29）汇总 Kotlin 生态的主要更新：Dokka 2.2.0 发布；KotlinConf’26 将于 5 月 20–22 日在慕尼黑举行，包含 KMP、AI、后端等实作工作坊，并刊登与 Josh Long 的对话。精选文章与工具包括 Mutflow（基于 K2 的单次编译突变测试插件）、AI 辅助的「Process Over Magic」流程、Process Watcher（通过监控 RSS、堆和 GC 帮助诊断 CI OOM），以及用 Koog 构建的多阶段研究代理。另有相关影片、赞助报告、Compose 课程与实用库（acli、kstats、SVG to Compose、WebAuthn MPP）介绍；稿件征集仍在进行，并感谢 JetBrains 的支持。

Kotlin Weekly 第504期

Dokka 2.2.0 發行；KotlinConf’26（5 月 20–22 日，慕尼黑）包含 KMP、AI、後端等工作坊，並刊出與 Josh Long 訪談。

重點摘要

Dokka 2.2.0 正式釋出，完整更新說明已公布。

KotlinConf’26（5/20–22，慕尼黑）提供多場實作工作坊與議程。

重點文章與工具：Mutflow（單次編譯突變測試）、Process Watcher（CI OOM 偵測）、Koog 深度研究代理。

Kotlin Weekly 第504期（2026-03-29）彙整 Kotlin 生態的重要消息：Dokka 2.2.0 發行；KotlinConf’26 將於 5 月 20–22 日在慕尼黑舉行，含 KMP、AI、後端等實作工作坊，並刊登與 Josh Long 的對談。本文節選了數篇技術文章與工具，包括 Mutflow（基於 K2 的單次編譯突變測試外掛）、以 AI 協助的「Process Over Magic」開發流程、Process Watcher（透過監控 RSS、堆積與 GC 協助診斷 CI OOM），以及用 Koog 建構的多階段研究代理。另有影片、贊助報告、Compose 課程與實用函式庫（acli、kstats、SVG to Compose、WebAuthn MPP）介紹，並邀稿且感謝 JetBrains 支持。

Integrating AR Features into Android Apps

Medium Kotlin 作者：Gulshan Yadav 發布：03-29 08:46

Integrating AR Features into Android Apps

Build immersive AR experiences on Android using ARCore, Sceneform, and Kotlin, with practical guidance on plane detection and core AR concepts.

重點摘要

Use ARCore and Sceneform with Kotlin

Implement plane detection, hit testing, and anchors

Render 3D models and manage basic user interactions

This article explains how to build immersive augmented reality experiences for Android using ARCore, Sceneform, and Kotlin. It serves as a practical, hands-on guide introducing core AR concepts—plane detection, hit testing, anchors, rendering 3D models, and basic user interactions—and outlines the required setup such as Gradle dependencies, device permissions, and AR session configuration. The author demonstrates how to detect horizontal and vertical surfaces, perform hit tests to place virtual objects, attach them to anchors so they persist in world space, and render them with Sceneform’s simplified APIs. The guide also discusses testing on supported devices and recommends performance and UX best practices to ensure stable tracking and smooth visuals. Aimed at Android developers familiar with Kotlin, it emphasizes concrete implementation steps to integrate AR features into apps without deep graphics expertise.

在 Android 应用中整合 AR 功能

使用 ARCore、Sceneform 与 Kotlin 在 Android 上构建沉浸式 AR，实践指南涵盖平面检测与核心概念。

重點摘要

使用 ARCore 与 Sceneform 结合 Kotlin 开发

实现平面检测、hit test 与锚点绑定

渲染 3D 模型并处理基本交互

本文介绍如何使用 ARCore、Sceneform 与 Kotlin 在 Android 上构建沉浸式增强现实体验。作为实践指南，说明基础 AR 概念（如平面检测、hit test、锚点设置）、Gradle 依赖、设备权限与 AR session 配置等必要步骤。作者演示检测水平与垂直面、通过 hit test 放置虚拟对象并绑定锚点以保持世界坐标位置，并使用 Sceneform 的渲染工具呈现模型。文章同时提及在支持设备上的测试以及性能与用户体验的最佳实践，适合熟悉 Kotlin 的 Android 开发者作为整合 AR 功能的实用参考。

在 Android 應用中整合 AR 功能

使用 ARCore、Sceneform 與 Kotlin 在 Android 上建構沉浸式 AR，實作導引涵蓋平面偵測與核心概念。

重點摘要

以 ARCore 與 Sceneform 結合 Kotlin 開發

實作平面偵測、hit test 與錨點綁定

呈現 3D 模型並處理基本互動

本文介紹如何使用 ARCore、Sceneform 與 Kotlin 在 Android 上建構沉浸式擴增實境體驗。作為實作導引，說明基礎 AR 概念（如平面偵測、hit test、錨點設定）、Gradle 相依、裝置權限與 AR session 設定等必備步驟。作者示範偵測水平與垂直面、以 hit test 放置虛擬物件並綁定錨點以維持世界座標位置，並用 Sceneform 的渲染工具呈現模型。文章同時提及在支援裝置上的測試與效能、使用者體驗最佳實務，適合熟悉 Kotlin 的 Android 開發者作為整合 AR 功能的實務指南。

Dynamic SSL Pinning on Android: Integrating the SDK and Walking Through the Implementation

Medium Kotlin 作者：Denis 發布：03-29 13:25

Dynamic SSL Pinning on Android: Integrating the SDK and Walking Through the Implementation

A series exploring dynamic SSL pinning on Android, focusing on SDK integration and an implementation walkthrough.

重點摘要

Topic: dynamic SSL pinning for Android apps

Focus on integrating a pinning SDK

Excerpt truncated — full article continues on Medium

Denis's Medium post, titled "Dynamic SSL Pinning on Android: Integrating the SDK and Walking Through the Implementation," introduces a series about implementing dynamic SSL pinning for Android applications. The piece states its focus on integrating a pinning SDK and providing a walkthrough of the implementation to help developers manage TLS trust through certificate pinning. The provided content is a truncated excerpt that only includes a "Continue reading on Medium" prompt, so the full technical content, examples, and step‑by‑step details are not present in the snippet. Based on the title, the series appears intended to cover practical integration steps, runtime behavior, and maintenance considerations for pinned certificates, but those sections must be consulted in the complete Medium article for concrete code samples and configuration guidance.

Dynamic SSL Pinning on Android：集成 SDK 与实现演练

该系列旨在探讨 Android 上的动态 SSL pinning，重点为 SDK 集成与实现过程演示。

重點摘要

主题：Android 的动态 SSL pinning

侧重于集成 pinning SDK

摘录被截断，完整内容请访问 Medium

作者 Denis 在 Medium 发布的文章《Dynamic SSL Pinning on Android：集成 SDK 与实现演练》介绍了一个关于在 Android 应用中实现动态 SSL pinning 的系列，说明其关注点为如何集成 pinning SDK 以及通过示例演练实现流程。当前可获取的内容仅为截断摘录，页面仅显示“Continue reading on Medium”链接，因此未包含完整的技术细节、代码示例或逐步指导。依据标题可推测系列计划涵盖实务集成步骤、运行时行为及凭证维护等议题，但具体示例与配置须阅读 Medium 上的完整文章以获取。

Dynamic SSL Pinning on Android：整合 SDK 與實作導覽

本系列探討在 Android 上實作動態 SSL pinning，著重於整合 SDK 與實作流程的示範。

重點摘要

主題：Android 的動態 SSL pinning

重點在於整合 pinning SDK

摘錄被截斷，完整內容請至 Medium 閱讀

作者 Denis 在 Medium 發表的文章標題為「Dynamic SSL Pinning on Android：整合 SDK 與實作導覽」，說明這是一個系列文章，聚焦於在 Android 應用中實作動態 SSL pinning、整合對應的 SDK 並逐步示範實作流程。原始提供的內容僅為截斷摘錄，頁面顯示「Continue reading on Medium」的導向連結，因而本文片段未包含具體程式範例、設定細節或逐步教學。從標題可見其意圖涵蓋實務整合步驟、執行時行為與憑證維護等考量，但欲取得完整的程式碼示例與設定說明，仍需前往 Medium 閱讀完整文章。

Didn’t Rewrite Your Native App For KMP. Evolved It

Medium Kotlin 作者：Ayman Alkurdi 發布：03-29 14:37

Didn’t Rewrite Your Native App For KMP. Evolved It

You don't need a full rewrite to go multiplatform — adopt Kotlin Multiplatform incrementally, one module at a time.

重點摘要

Kotlin Multiplatform can be introduced without rewriting the whole app

Adopt KMP incrementally by migrating one module at a time

Evolving the native app reduces risk and preserves existing platform features

The article argues that adopting Kotlin Multiplatform (KMP) doesn’t require a complete rewrite of an existing native app. Instead, you can evolve the app incrementally by migrating functionality module by module: pick bounded features, separate shared logic from platform-specific code, and integrate shared Kotlin gradually while keeping native UI and platform capabilities intact. This approach lowers risk, preserves previous engineering investment, and enables testing and iteration without a disruptive, all-at-once overhaul. Over time, more business logic can be centralized in shared modules to gain code reuse and easier cross-platform development, while minimizing impact on users and team velocity. The piece presents a practical, conservative strategy for moving toward multiplatform benefits without a big-bang rewrite.

没有为 KMP 重写原生 App，而是让它演进

无需全面重写即可实现跨平台：在现有 Android 应用中按模块逐步采用 Kotlin Multiplatform。

重點摘要

无需整体重写即可引入 Kotlin Multiplatform

按模块逐步迁移与整合共享 Kotlin 代码

逐步演进能降低风险并保留原生平台能力

作者指出，採用 Kotlin Multiplatform (KMP) 不必透過全面重寫現有原生應用。可以在既有 Android 應用中按模組逐步遷移：選取範圍有限的功能、清晰區分共享邏輯與平台特定代碼、漸進整合並持續測試。這種方法保留原生 UI 與平台能力，降低導入風險，保護既有投資，並讓工程團隊在不打斷使用者體驗與開發效率的前提下，逐漸累積可共享的業務邏輯。以模組為單位的演進路徑能在不進行大規模重寫的情況下，逐步獲得跨平台代碼重用的好處。

沒有為 KMP 重寫原生 App，而是讓它演進

不需要全面重寫即可跨平台：在現有 Android 應用中逐一模組採用 Kotlin Multiplatform。

重點摘要

不用整個重寫就能引入 Kotlin Multiplatform

以模組為單位逐步遷移與整合共用 Kotlin

逐步演進可降低風險並保留原生平台能力

作者說明無需全面重寫即可採用 Kotlin Multiplatform (KMP)。在既有 Android 應用上，透過逐步遷移每個模組來引入共用 Kotlin：挑選範圍有限的功能、為共用層與平台特定層劃清界線、逐步整合與測試。此策略保留既有原生 UI 與平台能力，降低導入風險、保護既有投資，並允許工程團隊在不影響使用者或開發速度的情況下累積可共用邏輯。以模組為單位的逐步演進可以逐漸換取跨平台代碼重用的好處，而非一次性的大規模重寫。

Supadroid: Sending Push Notifications on Supabase Database Events

Medium Kotlin 作者：Hieu Vu 發布：03-29 14:56

Supadroid: Sending Push Notifications on Supabase Database Events

I’ll walk you through my solution to send push notifications to an Android application based on Supabase database updates.

重點摘要

Trigger push notifications from Supabase database events

Integrate Supabase event hooks with an Android notification flow

Practical walkthrough of design, configuration and deployment considerations

This article presents a step-by-step walkthrough of the author's solution for sending push notifications to an Android application triggered by updates in a Supabase database. It covers the motivation for notifying mobile clients when backend data changes, explains how Supabase can surface database events, and describes routing those events to a push delivery mechanism that reaches Android devices. The author emphasizes practical integration: linking Supabase event hooks or triggers with a notification sender and ensuring the Android client receives and handles incoming notifications. Readers can expect an end-to-end perspective that addresses design choices, configuration details, and deployment considerations relevant to real-time notification flows tied to database changes, aimed at developers wanting a concrete pattern to connect Supabase events with mobile push notifications.

Supadroid：在 Supabase 数据库事件上发送推送通知

我将带你逐步了解我如何在 Supabase 数据库更新时向 Android 应用发送推送通知的方案。

重點摘要

通过 Supabase 数据库事件触发推送

将 Supabase 事件与 Android 通知流程集成

面向实务的设计、配置与部署要点

本文作者示范一种方案，说明如何在 Supabase 数据库更新时向 Android 应用发送推送通知。文章从需求与动机出发，介绍如何检测 Supabase 的数据变更事件，以及如何将这些事件转接到推送传递机制以送达移动设备。作者以实务整合为主线，说明事件触发、通知发送与 Android 客户端接收处理的要点，并讨论配置与部署时需要注意的方面。本文适合希望将 Supabase 数据事件与实时移动推送连接的开发者，提供具体的设计与整合方向。

Supadroid：在 Supabase 資料庫事件上發送推播通知

我將帶你逐步了解我如何在 Supabase 資料庫更新時向 Android 應用發送推播通知的解法。

重點摘要

以 Supabase 資料庫事件觸發推播

將 Supabase 事件與 Android 通知流程整合

實務導向的設計、設定與部署說明

本文作者示範一種解法，說明如何在 Supabase 資料庫更新時向 Android 應用發送推播通知。文章從需求與動機出發，介紹如何偵測 Supabase 的資料變更事件，以及如何將這些事件轉接到推播傳遞機制以送達行動裝置。作者以實務整合為主軸，說明事件觸發、通知發送與 Android 客戶端接收處理的要點，並討論設定與部署上需要注意的面向。本文適合尋求將 Supabase 資料事件與即時行動推播串接的開發者，提供具體的設計與整合方向。

Advanced Kotlin Part 4: Primary and Secondary Constructors in Kotlin

Medium Kotlin 作者：Kishor Ramani 發布：03-29 02:31

Advanced Kotlin Part 4: Primary and Secondary Constructors in Kotlin

Kotlin offers flexible ways to initialize objects — let's explore primary constructors, secondary constructors, and init blocks.

重點摘要

Kotlin provides flexible object initialization mechanisms

Distinguishes primary and secondary constructors for different construction flows

Init blocks allow additional initialization logic during object creation

This article introduces Kotlin's approaches to object initialization, focusing on primary constructors, secondary constructors, and init blocks. It outlines how these language features separate declaration from initialization responsibilities: primary constructors offer a concise way to declare and initialize properties at construction, while secondary constructors provide alternative construction paths for different parameter sets or setup needs. Init blocks are identified as the place to run initialization code that cannot be expressed in constructor parameter lists. Together, these mechanisms give Kotlin developers flexible patterns for creating and configuring objects according to design requirements. The piece aims to clarify when to prefer primary versus secondary constructors and how to use init blocks for additional setup or validation during object creation.

高级 Kotlin（第四部分）：Kotlin 的主构造函数与次构造函数

Kotlin 提供多种灵活的对象初始化方式——本文探讨主构造函数、次构造函数与 init 块的用途。

重點摘要

Kotlin 支持灵活的对象初始化机制

主构造与次构造用于处理不同的构建情景

init 块可用于执行额外的初始化或校验逻辑

本文介绍了 Kotlin 中对象初始化的多种做法，重点讲述 primary constructor（主构造函数）、secondary constructor（次构造函数）与 init 块的角色与差异。文中说明主构造函数如何以简洁语法在构建时声明并初始化属性，次构造函数则适用于需要不同参数组合或额外构建流程的场景，而 init 块可用于放置无法在参数列表中表达的初始化逻辑。这些机制共同赋予 Kotlin 在对象创建与配置方面的灵活性，适合希望澄清何时选择主构造、次构造以及如何使用 init 块进行额外设置或验证的开发者参考。

進階 Kotlin（第四部）：Kotlin 的主建構子與次建構子

Kotlin 提供多種彈性的物件初始化方式──本文探討主建構子、次建構子與 init 區塊的用途。

重點摘要

Kotlin 支援彈性的物件初始化策略

主建構子與次建構子分別處理不同的建立情境

init 區塊可執行額外的初始化或驗證邏輯

本文介紹 Kotlin 中物件初始化的多種做法，重點在於說明 primary constructor（主建構子）、secondary constructor（次建構子）與 init 區塊的角色與差異。文章說明主建構子如何以簡潔語法在建構時宣告並初始化屬性，次建構子則用於支援不同參數組合或需要額外建立流程的情況，而 init 區塊則可放置無法在參數列表中表達的初始化邏輯。這些機制合起來讓 Kotlin 在物件建立與設定上具有彈性，適合想釐清何時選用主建構子或次建構子、以及如何利用 init 區塊執行額外設定或驗證的開發者。

Handling App Crashes Gracefully: A Simple User-Aware Approach

Medium Kotlin 作者：Rohitraj Khorwal 發布：03-29 04:31

Handling App Crashes Gracefully: A Simple User-Aware Approach

When my app crashes, it just closes abruptly; from a user's perspective, it feels like the app is unstable or broken because there's no feedback.

重點摘要

Abrupt crashes make apps seem unstable to users.

A user-aware approach emphasizes communicating and preserving state.

Simple, lightweight interventions can improve perceived stability and trust.

Rohitraj Khorwal's article observes that when an app crashes it often closes abruptly, leaving users to perceive it as unstable or broken because there's no indication of what happened. The piece argues for a simple, user-aware approach to crash handling that prioritizes the user's experience rather than treating crashes purely as developer telemetry: communicate clearly when failures occur, preserve or recover important state when possible, and offer straightforward recovery or reporting options so users feel supported. By giving users feedback and choices after a failure, developers can reduce frustration, maintain trust, and collect useful context for debugging. The article focuses on practical, lightweight interventions that improve perceived stability without requiring complex infrastructure, stressing empathy and clarity as central to graceful crash handling.

优雅地处理应用崩溃：一种简单的以用户为中心的方法

当我的应用崩溃时，它会直接关闭；从用户角度看，因为没有任何反馈，会觉得应用不稳定或已损坏。

重點摘要

崩溃直接关闭会让用户觉得应用不稳定。

以用户为中心的处理应优先提供反馈并保留重要状态。

务实且轻量的措施能提升感知稳定性与用户信任。

作者指出，当应用程序崩溃时通常会直接关闭，用户因此感觉程序不稳定或已损坏，因为没有任何回应或说明。文章主张采用以用户为中心的简单崩溃处理方法，强调在错误发生时应向用户清楚沟通、保留或尝试还原重要状态，并提供易于理解的恢复或上报途径，以降低挫折感并维持信任。这类做法务实且轻量，不需大量基础设施即可改善感知稳定性，全文以同理心和清晰信息为核心，说明如何在不复杂化系统下优雅地处理崩溃。

優雅處理應用程式崩潰：一種簡單的以使用者為中心的方法

當我的應用程式崩潰時，它會直接關閉；從使用者角度看，因為沒有任何回應，會覺得應用不穩定或已損壞。

重點摘要

崩潰直接關閉讓使用者覺得應用不穩定。

以使用者為中心的處理應優先回饋並保留重要狀態。

務實且輕量的介入可提升感知穩定性與使用者信任。

作者指出，當應用程式崩潰時通常會直接關閉，使用者因此感覺程式不穩定或已損壞，因為沒有任何回應或說明。文章主張採用以使用者為中心的簡單崩潰處理方法，強調在錯誤發生時應向使用者清楚溝通、保留或嘗試還原重要狀態，並提供易於理解的回復或回報途徑，以降低挫折並維持信任。這類做法務實且輕量，不需大量基礎設施即可改善感知穩定性，全文以同理心與清晰資訊為核心，說明如何在不複雜化系統下優雅處理崩潰。

Advanced Kotlin Part 5: Inheritance in Kotlin — Reusing Code Effectively

Medium Kotlin 作者：Kishor Ramani 發布：03-29 04:31

Advanced Kotlin Part 5: Inheritance — Reusing Code Effectively

Inheritance lets you create new classes by reusing properties and functions from existing ones.

重點摘要

Reuse properties and functions from existing classes

Create new classes by extending existing behavior

Master inheritance to write more maintainable Kotlin code

This installment of the Advanced Kotlin series introduces inheritance as the mechanism for creating new classes by reusing properties and functions from existing ones. The short piece presents inheritance as a fundamental tool for reducing duplication and building on established behavior, framing it as a concept developers should master to improve code organization and maintainability. Readers are encouraged to deepen their understanding of how to structure hierarchies and leverage inherited members effectively in Kotlin projects. The article acts as a prompt to continue reading for concrete examples, guidance, and best practices on applying inheritance properly and responsibly in real-world code.

高级 Kotlin 第五篇：继承 — 有效重用代码

继承让你通过重用已有类的属性和函数来创建新类。

重點摘要

重用已有类的属性与函数

通过扩展已有行为创建新类

掌握继承以提高代码可维护性

本篇是 Advanced Kotlin 系列的第 5 篇，介绍继承这一机制：通过重用已有类的属性和函数来创建新类。文章指出继承是减少重复代码、构建基于既有行为的工具，建议开发者掌握如何组织类的层次结构并有效利用继承成员，从而编写更清晰、更易维护的 Kotlin 代码。作者并鼓励读者继续阅读原文以获取示例、实践指南与最佳实践，进一步理解在真实项目中如何恰当地应用继承以达到代码重用与可维护性的目标。

進階 Kotlin 第五篇：繼承 — 有效重用程式碼

繼承讓你透過重用既有類別的屬性與函式來建立新類別。

重點摘要

透過繼承重用屬性與函式

以既有行為為基礎建立新類別

掌握繼承以提升程式碼維護性

本篇為 Advanced Kotlin 系列的第 5 篇，介紹繼承（inheritance）這個機制：透過重用既有類別的屬性與函式來建立新類別。文章強調繼承可用來減少重複程式碼、延續既有行為，並建議開發者應熟悉如何設計類別階層與善用繼承成員，以便撰寫更有組織且易於維護的 Kotlin 程式。本文同時鼓勵讀者繼續閱讀原文以取得範例、實作指引與最佳實務，進一步了解在實際專案中如何有效且負責任地運用繼承。

Kotlin Coroutines — Part 2: Writing Real-World, Production-Ready Code

Medium Kotlin 作者：Pratik Banodkar 發布：03-29 04:38

Kotlin Coroutines — Part 2: Writing Real-World, Production-Ready Code

Building on Part 1's deep dive into continuations and suspension points, this article shows how to apply that knowledge to write production-ready coroutine code.

重點摘要

Continues from Part 1's exploration of coroutine internals

Focuses on applying internal concepts to production Kotlin code

Emphasizes practical patterns for reliability, testing, and maintainability

This second part builds on Part 1's deep dive into coroutine internals—continuations, suspension points, and compiler transformations—and focuses on applying that understanding to writing production-ready Kotlin code. It aims to bridge theory and practice by showing how internal concepts affect real-world design choices, error handling, cancellation, structured concurrency, and performance considerations. The article emphasizes pragmatic patterns, testing approaches, and defensive coding to make coroutine-based systems reliable and maintainable in production. It also covers pragmatic concerns such as resource management, concurrency boundaries, observable side effects, and strategies for testing and debugging asynchronous code. Overall, the piece is intended for Kotlin developers who understand coroutine internals and want concrete guidance for making coroutine-based systems robust, debuggable, and performant in production environments.

Kotlin 协程 — 第二部分：编写适用于真实世界、可投入生产的代码

在第一部分深入探讨 continuation 与 suspension point 等协程内部机制之后，本文说明如何将这些知识应用于编写可投入生产的 Kotlin 协程代码。

重點摘要

延续第一部分对协程内部机制的解析

侧重将底层概念应用到生产环境的代码实践

强调可靠性、测试与可维护性的实用模式

第二部分在第一部分深入探讨协程内部运作（如 continuation 与 suspension point）的基础上，聚焦于如何将这些底层概念应用到可投入生产的 Kotlin 协程代码中。文章旨在把理论与实践连接起来，说明内部机制如何影响实际设计选择、错误处理、取消与结构化并发，以及性能考量，並提出資源管理、并发边界与异步调试测试的实务建议，帮助开发者将协程相关的底层理解转化为稳健、可维护且便于排查问题的生产级代码。

Kotlin 協程 — 第二部分：撰寫適用於真實世界、可投入生產的程式碼

在第一部分深入探討 continuation 與 suspension point 等協程內部運作後，本篇說明如何將這些知識應用於撰寫可投入生產的 Kotlin 協程程式碼。

重點摘要

延續第一部分對協程內部運作的探討

著重將底層概念應用到生產環境的程式設計

強調可靠性、測試與可維護性的實務模式

第二部分在第一部分深入探討協程內部運作（如 continuation 與 suspension point）的基礎上，聚焦於如何將這些底層概念應用到可投入生產的 Kotlin 協程程式設計。文章說明如何在實際專案中以結構化併發、取消與錯誤處理、資源管理與測試為導向，設計可維護、可靠且易於除錯的非同步流程，並強調在選擇 scope、dispatcher 與異步資料流時應注意的實務考量，幫助開發者將理論轉化為穩健的生產力程式碼。

Part 6: The Interceptor Pattern — Mastering the Token Lifecycle

Medium Kotlin 作者：Sivavishnu 發布：03-29 06:19

Part 6: The Interceptor Pattern — Mastering the Token Lifecycle

A staff-level guide to using OkHttp Authenticator and a Kotlin Mutex to prevent refresh storms and race conditions in high-scale apps.

重點摘要

Use OkHttp Authenticator to centralize token refresh logic

Employ Kotlin Mutex to serialize refresh and avoid concurrent refreshes

Prevent refresh storms and race conditions in high-scale services

This staff-level guide explains how to apply the Interceptor pattern to master the token lifecycle in high-scale Kotlin applications. It focuses on using OkHttp's Authenticator together with a Kotlin Mutex to coordinate token refresh operations, preventing "refresh storms" where many concurrent requests trigger duplicate refreshes, and avoiding race conditions during token replacement. The article outlines how an authenticator-based approach centralizes refresh logic at the HTTP client layer while a mutex serializes the refresh sequence, ensuring only one refresh runs at a time and other requests wait or retry appropriately. The result is more reliable authentication, fewer redundant network calls, and improved scalability. Aimed at senior engineers, the guide offers practical pattern-level advice for implementing robust token management with OkHttp and Kotlin primitives in production services.

第六部分：拦截器模式 — 精通 Token 生命周期

一篇资深工程师级别的指南，说明如何结合 OkHttp Authenticator 与 Kotlin Mutex 在高并发应用中避免刷新风暴和竞态条件。

重點摘要

使用 OkHttp Authenticator 集中处理 token 刷新

利用 Kotlin Mutex 序列化刷新以避免并发刷新

在高并发服务中防止刷新风暴和竞态问题

本文为资深工程师级别的实现指引，说明如何以拦截器（Interceptor）模式掌握 token 生命周期：结合 OkHttp 的 Authenticator 与 Kotlin 的 Mutex 协调 token 刷新，避免在高流量环境中发生多个请求同时触发重复刷新（refresh storm）及因同步竞争造成的 race condition。文中说明将刷新逻辑集中于 HTTP 客户端层，并以互斥锁序列化刷新流程，使得同时到达的请求能排队或重试，确保仅有一个刷新执行，减少冗余网络调用并提升系统可靠性与扩展性。

第六部：攔截器模式 — 精通 Token 生命週期

一篇資深工程師級別的指引，說明如何結合 OkHttp Authenticator 與 Kotlin Mutex 以在高流量應用中避免刷新風暴與 race condition。

重點摘要

以 OkHttp Authenticator 集中管理 token 刷新

使用 Kotlin Mutex 序列化刷新以避免同時刷新

在高流量系統中防止刷新風暴與競爭條件

本文為資深工程師級別的實作指引，說明如何以攔截器（Interceptor）模式掌握 token 生命週期：結合 OkHttp 的 Authenticator 與 Kotlin 的 Mutex 協調 token 刷新，避免在高流量環境中發生多重請求同時觸發重複刷新（refresh storm）及因同步競爭造成的 race condition。文中說明將刷新邏輯集中於 HTTP 客戶端層，並以互斥鎖序列化刷新流程，使得同時到達的請求能排隊或重試，確保僅有一個刷新執行，減少冗餘網路呼叫並提升系統可靠性與擴展性。