从JDK源码到App开发：你一定要学会的设计模式！

一、JDK源码里的设计模式有多“高级”？

JDK作为Java最基础、最经典的库，处处都是设计模式的身影。上篇我们聚焦了工厂、建造者、装饰者、适配器等对象创建和结构型模式，这一篇聚焦于JDK中集合（Collections）、观察者（Observer）、运行时动态扩展（如Filter/Interceptor）等典型模式。
这些模式的思想和技巧在移动端开发领域同样极具参考价值。

二、Collections.sort：策略模式和回调的灵活协作

2.1 JDK源码中的策略模式

在JDK的集合库（如ArrayList、Collections等）中，排序的核心是策略模式+回调。比如：

public static <T> void sort(List<T> list, Comparator<? super T> c)

Comparator是排序策略的抽象，开发者可自定义比较逻辑传入。

App开发类比——Swift中的策略模式排序

let list = ["apple", "orange", "banana"]
let sorted = list.sorted { $0.count < $1.count }  // 以字符串长度排序

• o 这里的闭包{ $0.count < $1.count }就是一个策略。

App开发类比——Kotlin中的策略模式排序

val list = listOf("apple", "orange", "banana")
val sorted = list.sortedBy { it.length }

• o Kotlin的sortedBy接收lambda表达式，灵活指定排序策略。

2.2 真实项目中的场景拓展

• o 用户列表按昵称、活跃度等自定义规则排序
• o 电商App的商品根据价格、销量、综合得分等灵活切换排序方式
• o 本地数据存储、消息/聊天记录等自定义筛选和排序

总结：
策略模式让你的App支持灵活定制算法，便于拓展与测试。

三、观察者模式：事件驱动编程的基石

3.1 JDK源码中的Observer与Observable

JDK原生提供了Observer和Observable两个类，典型接口如下：

public interface Observer {
    void update(Observable o, Object arg);
}
public class Observable {
    private Vector observers;
    public synchronized void addObserver(Observer o) { ... }
    public void notifyObservers(Object arg) { ... }
}

核心思想：一对多依赖，当被观察对象发生变化时，所有观察者会自动收到通知。

Swift中的观察者模式实现

protocol Observer: AnyObject {
    func update(_ message: String)
}
class Observable {
    private var observers = [Observer]()
    func addObserver(_ observer: Observer) { observers.append(observer) }
    func notifyObservers(_ message: String) {
        observers.forEach { $0.update(message) }
    }
}

比如：在App中，网络状态变化、主题切换、账号登录登出等，使用观察者通知所有相关界面刷新。

Kotlin中的观察者模式实现

interface Observer {
    fun update(message: String)
}
class Observable {
    private val observers = mutableListOf<Observer>()
    fun addObserver(observer: Observer) { observers.add(observer) }
    fun notifyObservers(message: String) {
        observers.forEach { it.update(message) }
    }
}

比如：IM消息推送、文件上传进度更新、UI主题切换等。

3.2 JDK Observer的“changed”机制和最佳实践

JDK的Observable只有在调用setChanged()后，才会通过notifyObservers真正触发通知。
这种方式保证了只有关键变更时才通知，避免性能浪费和无谓的UI刷新。

移动端实践建议

• o 当网络、数据模型、用户状态等发生本质变化时再发事件，避免重复、无用通知
• o 配合事件去抖（debounce）、节流（throttle）等手段提升App性能和体验

3.3 现代App中更推荐的观察者/订阅发布框架

• o Swift/Combine、Kotlin/Flow/RxJava等响应式流式编程，完美实现复杂的数据流、UI同步、后台任务监听。
• o 各类“事件总线”（EventBus）解耦复杂模块间的消息通知，如IM消息分发、全局推送等。

四、运行时扩展：灵活的Filter/Interceptor链

4.1 JDK中的Filter链

如Servlet的Filter机制，可对HTTP请求做一系列链式处理（如权限、日志、缓存等）：

public interface Filter {
    void doFilter(ServletRequest request, ServletResponse response, FilterChain chain);
}

类似思想在移动端场景中同样常见。

Swift的Filter链/拦截器应用

protocol NetworkInterceptor {
    func intercept(_ request: URLRequest) -> URLRequest
}
class AuthInterceptor: NetworkInterceptor { ... }
class LoggingInterceptor: NetworkInterceptor { ... }

class NetworkClient {
    let interceptors: [NetworkInterceptor]
    func send(_ request: URLRequest) {
        var req = request
        for interceptor in interceptors {
            req = interceptor.intercept(req)
        }
        // 发送网络请求
    }
}

应用场景：请求签名、token自动注入、日志打印、缓存处理等。

Kotlin的拦截器链（比如OkHttp）

interface Interceptor {
    fun intercept(chain: Chain): Response
}
class LoggingInterceptor: Interceptor { ... }
class AuthInterceptor: Interceptor { ... }

class NetworkClient(val interceptors: List<Interceptor>) {
    fun send(request: Request) {
        var chain = interceptors
        // 遍历所有拦截器执行链式处理
        // ...
    }
}

应用场景：鉴权、加解密、调试日志、埋点采集、断点续传等。

五、JDK设计模式对App开发的启示

5.1 不同模式的工程价值

• o 策略模式：使算法/业务逻辑灵活切换，典型于排序、筛选、价格计算等场景。
• o 观察者模式：实现一对多通知/事件驱动，是数据流与UI联动、消息总线、全局事件监听的关键基础。
• o Filter/拦截器链：保证核心业务流程可插拔扩展，提升网络、数据、功能安全等跨层能力。

5.2 结合移动端实际的常见应用

• o 商品/用户/内容自定义排序
  灵活切换“推荐”、“热度”、“最新”展示，策略模式让代码优雅可扩展。
• o 主题切换/推送/用户状态感知
  观察者让多页面、多模块保持同步，避免手动刷新、全局单例污染。
• o 网络/数据库/IO操作的Filter链
  网络请求统一做日志、鉴权、重试；数据库操作可插拔加密、本地缓存等。

5.3 注意事项和最佳实践

• o 不要滥用设计模式，只为真实业务做合理抽象，保持代码简洁可维护。
• o 提前设计扩展点，不要为“假想需求”堆砌过度复杂的架构。
• o 多参考JDK和优秀开源项目源码，学习其抽象与扩展的平衡。

六、App工程级代码场景举例

6.1 商品排序功能

Kotlin示例：

enum class SortType { PRICE, SALES, SCORE }
class Product(val price: Double, val sales: Int, val score: Double)
fun sortProducts(products: List<Product>, type: SortType): List<Product> =
    when(type) {
        SortType.PRICE -> products.sortedBy { it.price }
        SortType.SALES -> products.sortedByDescending { it.sales }
        SortType.SCORE -> products.sortedByDescending { it.score }
    }

Swift示例：

enum SortType { case price, sales, score }
struct Product { let price: Double; let sales: Int; let score: Double }
func sortProducts(_ products: [Product], by type: SortType) -> [Product] {
    switch type {
    case .price: return products.sorted { $0.price < $1.price }
    case .sales: return products.sorted { $0.sales > $1.sales }
    case .score: return products.sorted { $0.score > $1.score }
    }
}

6.2 网络层的观察者/事件驱动

Kotlin示例（简化版EventBus）

interface NetworkStateListener { fun onStateChanged(isConnected: Boolean) }
class NetworkManager {
    private val listeners = mutableListOf<NetworkStateListener>()
    fun register(listener: NetworkStateListener) { listeners.add(listener) }
    fun notifyStateChange(isConnected: Boolean) {
        listeners.forEach { it.onStateChanged(isConnected) }
    }
}

Swift Combine简例

import Combine
class NetworkStatePublisher {
    static let shared = NetworkStatePublisher()
    let subject = PassthroughSubject<Bool, Never>()
}
// 订阅
let cancellable = NetworkStatePublisher.shared.subject
    .sink { isConnected in print("网络状态变化: \(isConnected)") }

6.3 网络请求Filter链

Kotlin拦截器链结构：

class NetworkClient(val interceptors: List<Interceptor>) {
    fun execute(request: Request): Response {
        var req = request
        interceptors.forEach { req = it.intercept(req) }
        // 真实发送请求...
    }
}

Swift多层处理：

protocol RequestFilter { func filter(_ request: URLRequest) -> URLRequest }
class NetworkClient {
    var filters: [RequestFilter] = []
    func send(_ req: URLRequest) {
        let final = filters.reduce(req) { $1.filter($0) }
        // 发送final
    }
}

七、总结与实践建议

• o JDK中的设计模式源于工程痛点，绝非“炫技”——都可迁移至Swift/Kotlin工程实践。
• o App开发应针对真实的多变需求有选择性地引入设计模式，提升可扩展性和维护性。
• o 多研究JDK与知名开源库源码，理解“接口、抽象、策略、监听、链式扩展”等通用思想。