结构型模式 ⭐⭐

// ====== Target：新系统期望的接口 ======
interface Logger {
    // 新系统要求的日志方法：需要日志级别 + 消息
    fun log(level: Level, message: String)
}
 
// ====== Adaptee：已有的老旧日志类，接口不兼容 ======
class OldLogger {
    // 老旧方法：只接受一个字符串，没有级别概念
    fun logMessage(msg: String) {
        println(msg)  // 内部直接打印
    }
}
 
// ====== Adapter：适配器，将 OldLogger 适配成 Logger ======
class LoggerAdapter(
    private val oldLogger: OldLogger  // 持有被适配者的引用（组合）
) : Logger {
 
    // 实现 Target 接口的方法
    override fun log(level: Level, message: String) {
        // 将新接口的参数"转换"成老接口能接受的格式
        val formatted = "[${level.name}] $message"
        // 委托给老旧日志类完成实际工作
        oldLogger.logMessage(formatted)
    }
}

// ====== Target：系统统一的播放器接口 ======
interface MediaPlayer {
    // 播放指定文件
    fun play(fileName: String)
    // 停止播放
    fun stop()
}
 
// ====== Adaptee：第三方 VLC 引擎，接口风格完全不同 ======
open class VlcEngine {
    // VLC 引擎的打开文件方法
    fun openFile(path: String) {
        println("VlcEngine: opening $path")
    }
    // VLC 引擎的开始解码方法
    fun startDecoding() {
        println("VlcEngine: decoding started")
    }
    // VLC 引擎的释放资源方法
    fun releaseResource() {
        println("VlcEngine: resources released")
    }
}
 
// ====== 类适配器：同时继承 VlcEngine + 实现 MediaPlayer ======
// Kotlin 中 VlcEngine 必须标记为 open 才能被继承
class VlcAdapter : VlcEngine(), MediaPlayer {
 
    // 实现 Target 的 play 方法
    override fun play(fileName: String) {
        // 直接调用从父类 VlcEngine 继承来的方法（无需持有引用）
        openFile(fileName)     // 继承的方法：打开文件
        startDecoding()        // 继承的方法：开始解码
    }
 
    // 实现 Target 的 stop 方法
    override fun stop() {
        releaseResource()      // 继承的方法：释放资源
    }
}
 
// ====== Client 使用 ======
fun main() {
    // Client 只认识 MediaPlayer 接口
    val player: MediaPlayer = VlcAdapter()
    player.play("music.vlc")  // 内部自动转换成 VLC 引擎的调用
    player.stop()              // 内部自动释放资源
}

// ====== Target：同上，系统统一的播放器接口 ======
interface MediaPlayer {
    fun play(fileName: String)
    fun stop()
}
 
// ====== Adaptee：VLC 引擎（不需要 open，因为不再被继承）======
class VlcEngine {
    fun openFile(path: String) {
        println("VlcEngine: opening $path")
    }
    fun startDecoding() {
        println("VlcEngine: decoding started")
    }
    fun releaseResource() {
        println("VlcEngine: resources released")
    }
}
 
// ====== 对象适配器：持有 VlcEngine 实例，实现 MediaPlayer ======
class VlcAdapter(
    // 通过构造函数注入 Adaptee 实例（组合关系）
    private val engine: VlcEngine
) : MediaPlayer {
 
    override fun play(fileName: String) {
        // 委托给内部持有的 engine 实例
        engine.openFile(fileName)   // 委托调用：打开文件
        engine.startDecoding()      // 委托调用：开始解码
    }
 
    override fun stop() {
        engine.releaseResource()    // 委托调用：释放资源
    }
}
 
// ====== Client 使用 ======
fun main() {
    // 可以在运行时注入不同的 VlcEngine 实例（甚至是其子类）
    val engine = VlcEngine()
    val player: MediaPlayer = VlcAdapter(engine)
    player.play("music.vlc")
    player.stop()
}

// ====== 使用 Kotlin by 关键字实现委托适配 ======
 
// 假设 Target 接口有很多方法，手动逐个委托很繁琐
interface AdvancedLogger {
    fun debug(msg: String)   // 调试日志
    fun info(msg: String)    // 信息日志
    fun warn(msg: String)    // 警告日志
    fun error(msg: String)   // 错误日志
}
 
// 一个默认的日志实现
class ConsoleLogger : AdvancedLogger {
    override fun debug(msg: String) = println("[DEBUG] $msg")
    override fun info(msg: String) = println("[INFO] $msg")
    override fun warn(msg: String) = println("[WARN] $msg")
    override fun error(msg: String) = println("[ERROR] $msg")
}
 
// 适配器：大部分方法委托给 base，仅重写需要定制的方法
class FilteredLoggerAdapter(
    base: AdvancedLogger            // 被委托的目标实例
) : AdvancedLogger by base {       // by 关键字：自动委托所有方法给 base
 
    // 只重写 debug 方法：过滤掉调试日志（生产环境不输出）
    override fun debug(msg: String) {
        // 什么也不做，相当于过滤掉 debug 级别的日志
    }
    // info、warn、error 自动委托给 base，无需手写
}

// ====== 数据模型（Adaptee 中的数据）======
data class User(
    val id: Long,          // 用户唯一 ID
    val name: String,      // 用户名
    val avatarUrl: String  // 头像 URL
)
 
// ====== ViewHolder：RecyclerView 的视图复用单元 ======
class UserViewHolder(
    itemView: View  // 每一行 item 的根视图
) : RecyclerView.ViewHolder(itemView) {
 
    // 通过 findViewById 获取子视图引用（也可用 ViewBinding）
    val tvName: TextView = itemView.findViewById(R.id.tv_name)
    val ivAvatar: ImageView = itemView.findViewById(R.id.iv_avatar)
 
    // 将数据绑定到视图上（封装绑定逻辑）
    fun bind(user: User) {
        tvName.text = user.name                   // 设置用户名文本
        Glide.with(itemView).load(user.avatarUrl) // 使用 Glide 加载头像
            .into(ivAvatar)
    }
}
 
// ====== Adapter：核心适配器，连接数据与 RecyclerView ======
class UserAdapter(
    private var users: List<User> = emptyList()  // 持有数据源引用（组合）
) : RecyclerView.Adapter<UserViewHolder>() {
 
    // ① 创建 ViewHolder：RecyclerView 需要新的视图时调用
    override fun onCreateViewHolder(
        parent: ViewGroup,   // 父容器（即 RecyclerView 本身）
        viewType: Int        // 视图类型（多类型列表时有用）
    ): UserViewHolder {
        // 从 XML 布局文件 inflate 出 item 视图
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_user, parent, false)
        // 用 item 视图创建 ViewHolder 并返回
        return UserViewHolder(view)
    }
 
    // ② 绑定数据：将指定位置的数据绑定到 ViewHolder 上
    override fun onBindViewHolder(
        holder: UserViewHolder,  // 要绑定数据的 ViewHolder
        position: Int            // 当前 item 在列表中的位置
    ) {
        // 从数据源中取出对应位置的 User
        val user = users[position]
        // 委托给 ViewHolder 的 bind 方法完成绑定
        holder.bind(user)
    }
 
    // ③ 返回数据项总数：RecyclerView 据此决定滚动范围等
    override fun getItemCount(): Int = users.size
 
    // 更新数据源的方法
    fun submitList(newUsers: List<User>) {
        users = newUsers                 // 替换数据源
        notifyDataSetChanged()           // 通知 RecyclerView 全量刷新（粗暴但简单）
    }
}

┌──────────────────────────────────────────────────────┐
│             适配器模式角色映射                          │
├──────────────┬───────────────────────────────────────┤
│   Target     │  RecyclerView 期望的接口               │
│              │  (onCreateViewHolder,                  │
│              │   onBindViewHolder, getItemCount)      │
├──────────────┼───────────────────────────────────────┤
│   Adaptee    │  List<User> 原始数据源                  │
├──────────────┼───────────────────────────────────────┤
│   Adapter    │  UserAdapter                           │
│              │  将 List<User> 转换为 ViewHolder 视图    │
├──────────────┼───────────────────────────────────────┤
│   Client     │  RecyclerView + LayoutManager          │
│              │  只调用 Adapter 的标准接口方法            │
└──────────────┴───────────────────────────────────────┘

// ====== DiffUtil.ItemCallback：定义如何比较两个 item ======
// 这是 DiffUtil 算法的核心配置，告诉框架如何判断"相同"和"内容是否变化"
class UserDiffCallback : DiffUtil.ItemCallback<User>() {
 
    // 判断两个 item 是否代表"同一个对象"（通常比较唯一 ID）
    // 用于判断 item 是新增、删除还是移动
    override fun areItemsTheSame(oldItem: User, newItem: User): Boolean {
        return oldItem.id == newItem.id  // ID 相同即为同一用户
    }
 
    // 判断两个相同 item 的"内容是否发生了变化"
    // 只在 areItemsTheSame 返回 true 时才会调用
    // 用于判断是否需要重新绑定（刷新视图）
    override fun areContentsTheSame(oldItem: User, newItem: User): Boolean {
        return oldItem == newItem  // data class 自动生成 equals，比较所有字段
    }
}
 
// ====== ListAdapter：继承自 RecyclerView.Adapter，内置 DiffUtil ======
class UserListAdapter : ListAdapter<User, UserViewHolder>(
    UserDiffCallback()  // 传入差异比较回调
) {
 
    // 创建 ViewHolder（与普通 Adapter 完全一致）
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): UserViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_user, parent, false)
        return UserViewHolder(view)
    }
 
    // 绑定数据：使用 getItem(position) 而非直接访问 list
    override fun onBindViewHolder(holder: UserViewHolder, position: Int) {
        // getItem() 是 ListAdapter 提供的方法，从内部 AsyncListDiffer 获取数据
        val user = getItem(position)
        holder.bind(user)
    }
 
    // ⚠️ 不需要重写 getItemCount()！ListAdapter 内部已自动管理
}
 
// ====== Activity / Fragment 中使用 ======
class UserFragment : Fragment() {
 
    private val adapter = UserListAdapter()
 
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // 设置 RecyclerView
        recyclerView.adapter = adapter
        recyclerView.layoutManager = LinearLayoutManager(requireContext())
 
        // 观察数据变化，自动提交新列表
        viewModel.users.observe(viewLifecycleOwner) { newList ->
            // submitList 内部自动在后台线程执行 DiffUtil 计算
            // 计算完成后在主线程精确刷新变化的 item，并自动触发动画
            adapter.submitList(newList)
        }
    }
}

// ====== 多视图类型示例 ======
class MultiTypeAdapter : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
 
    companion object {
        const val TYPE_HEADER = 0   // 头部类型
        const val TYPE_CONTENT = 1  // 内容类型
        const val TYPE_AD = 2       // 广告类型
    }
 
    private var items: List<Any> = emptyList()  // 混合类型数据源
 
    // 根据数据类型返回不同的 viewType 标识
    override fun getItemViewType(position: Int): Int {
        return when (items[position]) {
            is HeaderData -> TYPE_HEADER    // 如果是头部数据
            is ContentData -> TYPE_CONTENT  // 如果是内容数据
            is AdData -> TYPE_AD            // 如果是广告数据
            else -> throw IllegalArgumentException("Unknown type")
        }
    }
 
    // 根据 viewType 创建不同的 ViewHolder
    override fun onCreateViewHolder(
        parent: ViewGroup,
        viewType: Int
    ): RecyclerView.ViewHolder {
        val inflater = LayoutInflater.from(parent.context)
        return when (viewType) {
            // 头部：inflate 头部布局，创建头部 ViewHolder
            TYPE_HEADER -> HeaderViewHolder(
                inflater.inflate(R.layout.item_header, parent, false)
            )
            // 内容：inflate 内容布局，创建内容 ViewHolder
            TYPE_CONTENT -> ContentViewHolder(
                inflater.inflate(R.layout.item_content, parent, false)
            )
            // 广告：inflate 广告布局，创建广告 ViewHolder
            TYPE_AD -> AdViewHolder(
                inflater.inflate(R.layout.item_ad, parent, false)
            )
            else -> throw IllegalArgumentException("Unknown viewType: $viewType")
        }
    }
 
    // 根据 ViewHolder 类型执行不同的绑定逻辑
    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        when (holder) {
            is HeaderViewHolder -> holder.bind(items[position] as HeaderData)
            is ContentViewHolder -> holder.bind(items[position] as ContentData)
            is AdViewHolder -> holder.bind(items[position] as AdData)
        }
    }
 
    override fun getItemCount(): Int = items.size
}

// ====== RecyclerView 内部简化逻辑（Java）======
// 位于 RecyclerView.java 源码中
 
// 当需要展示某个位置的 item 时
ViewHolder tryGetViewHolderForPositionByDeadline(int position, ...) {
    ViewHolder holder = null;
 
    // 第一步：尝试从缓存池（RecycledViewPool）获取复用的 ViewHolder
    holder = getRecycledViewPool().getRecycledView(viewType);
 
    if (holder == null) {
        // 缓存池中没有可复用的，调用 Adapter 创建新的
        // 这就是我们重写的 onCreateViewHolder 被调用的时机
        holder = mAdapter.createViewHolder(this, viewType);
    }
 
    // 第二步：调用 Adapter 将数据绑定到 ViewHolder
    // 这就是我们重写的 onBindViewHolder 被调用的时机
    mAdapter.bindViewHolder(holder, position);
 
    return holder;  // 返回准备好的 ViewHolder 给布局系统
}

// ====== 旧版 ListView 的 BaseAdapter（已不推荐使用）======
class OldUserAdapter(
    private val context: Context,
    private val users: List<User>
) : BaseAdapter() {
 
    // 返回数据项总数
    override fun getCount(): Int = users.size
 
    // 返回指定位置的数据对象
    override fun getItem(position: Int): Any = users[position]
 
    // 返回 item ID（通常返回 position）
    override fun getItemId(position: Int): Long = position.toLong()
 
    // 核心方法：返回每个 item 的视图
    // convertView 是系统尝试复用的旧视图（可能为 null）
    override fun getView(position: Int, convertView: View?, parent: ViewGroup?): View {
        val view: View
        val holder: ViewHolder
 
        if (convertView == null) {
            // 没有可复用的视图，需要新创建
            view = LayoutInflater.from(context)
                .inflate(R.layout.item_user, parent, false)
            // 创建 ViewHolder 并缓存到 view 的 tag 中（手动复用模式）
            holder = ViewHolder(view)
            view.tag = holder  // ⚠️ 这个 tag 复用模式很容易出错
        } else {
            // 有可复用的视图，直接取出 ViewHolder
            view = convertView
            holder = view.tag as ViewHolder
        }
 
        // 绑定数据
        holder.bind(users[position])
        return view
    }
}

// =============================================
// 1. 抽象组件：定义咖啡的统一接口
// =============================================
interface Coffee {
    fun cost(): Double      // 获取价格
    fun description(): String // 获取描述
}
 
// =============================================
// 2. 具体组件：基础咖啡种类
// =============================================
class Americano : Coffee {
    // 美式咖啡，基础价格 15.0
    override fun cost(): Double = 15.0
    // 返回基础描述
    override fun description(): String = "美式咖啡"
}
 
class Latte : Coffee {
    // 拿铁咖啡，基础价格 20.0
    override fun cost(): Double = 20.0
    // 返回基础描述
    override fun description(): String = "拿铁咖啡"
}
 
// =============================================
// 3. 抽象装饰器：持有 Coffee 引用，并实现 Coffee 接口
//    注意：它本身也是一个 Coffee，这是装饰器可以层层嵌套的关键
// =============================================
abstract class CoffeeDecorator(
    protected val coffee: Coffee  // 持有被装饰对象的引用（组合）
) : Coffee {
    // 默认委托给被装饰对象，子类可以在此基础上增强
    override fun cost(): Double = coffee.cost()
    override fun description(): String = coffee.description()
}
 
// =============================================
// 4. 具体装饰器：每个装饰器负责"添加"一种配料
// =============================================
class MilkDecorator(coffee: Coffee) : CoffeeDecorator(coffee) {
    // 在原有价格基础上加 3.0（牛奶的价格）
    override fun cost(): Double = super.cost() + 3.0
    // 在原有描述后面追加牛奶信息
    override fun description(): String = "${super.description()} + 牛奶"
}
 
class SugarDecorator(coffee: Coffee) : CoffeeDecorator(coffee) {
    // 在原有价格基础上加 1.5（糖的价格）
    override fun cost(): Double = super.cost() + 1.5
    // 在原有描述后面追加糖的信息
    override fun description(): String = "${super.description()} + 糖"
}
 
class MochaDecorator(coffee: Coffee) : CoffeeDecorator(coffee) {
    // 在原有价格基础上加 5.0（摩卡的价格）
    override fun cost(): Double = super.cost() + 5.0
    // 在原有描述后面追加摩卡信息
    override fun description(): String = "${super.description()} + 摩卡"
}

fun main() {
    // ====== 第一杯：美式 + 牛奶 + 糖 ======
    // 从最内层（原始对象）开始，一层一层包裹装饰器
    var coffee: Coffee = Americano()           // 核心：美式
    coffee = MilkDecorator(coffee)             // 第1层装饰：加牛奶
    coffee = SugarDecorator(coffee)            // 第2层装饰：加糖
 
    // 调用时，调用链从最外层逐层委托到最内层再逐层返回
    println(coffee.description())  // 输出: 美式咖啡 + 牛奶 + 糖
    println(coffee.cost())         // 输出: 19.5 (15 + 3 + 1.5)
 
    // ====== 第二杯：拿铁 + 双份摩卡 ======
    var fancy: Coffee = Latte()                // 核心：拿铁
    fancy = MochaDecorator(fancy)              // 第1层装饰：加摩卡
    fancy = MochaDecorator(fancy)              // 第2层装饰：再加一份摩卡（可以重复叠加！）
 
    println(fancy.description())   // 输出: 拿铁咖啡 + 摩卡 + 摩卡
    println(fancy.cost())          // 输出: 30.0 (20 + 5 + 5)
}

// =============================================
// 抽象组件：网络服务接口
// =============================================
interface ApiService {
    fun fetchData(url: String): String  // 发起网络请求并返回数据
}
 
// =============================================
// 具体组件：真正执行网络请求的实现
// 这个类我们"不能"或"不想"修改
// =============================================
class RealApiService : ApiService {
    override fun fetchData(url: String): String {
        // 模拟真实的 HTTP 请求
        return "Response from $url"
    }
}
 
// =============================================
// 抽象装饰器
// =============================================
abstract class ApiServiceDecorator(
    protected val wrapped: ApiService  // 被装饰的服务
) : ApiService
 
// =============================================
// 具体装饰器 1：日志装饰器 —— 在请求前后打印日志
// =============================================
class LoggingDecorator(wrapped: ApiService) : ApiServiceDecorator(wrapped) {
    override fun fetchData(url: String): String {
        // 请求前：打印开始日志
        Log.d("ApiService", ">>> 开始请求: $url")
        // 委托给被装饰对象执行真正的请求
        val result = wrapped.fetchData(url)
        // 请求后：打印结束日志（包含响应长度）
        Log.d("ApiService", "<<< 请求完成: ${result.length} bytes")
        // 将原始结果原封不动返回
        return result
    }
}
 
// =============================================
// 具体装饰器 2：缓存装饰器 —— 如果有缓存则直接返回
// =============================================
class CachingDecorator(wrapped: ApiService) : ApiServiceDecorator(wrapped) {
    // 内部维护一个简单的缓存 Map
    private val cache = mutableMapOf<String, String>()
 
    override fun fetchData(url: String): String {
        // 检查缓存：命中则直接返回，不再走网络
        cache[url]?.let {
            Log.d("ApiService", "缓存命中: $url")
            return it  // 提前返回，短路后续调用
        }
        // 缓存未命中：委托给被装饰对象请求
        val result = wrapped.fetchData(url)
        // 将结果存入缓存，供下次使用
        cache[url] = result
        return result
    }
}
 
// =============================================
// 具体装饰器 3：重试装饰器 —— 失败时自动重试
// =============================================
class RetryDecorator(
    wrapped: ApiService,
    private val maxRetries: Int = 3  // 最大重试次数，默认 3 次
) : ApiServiceDecorator(wrapped) {
 
    override fun fetchData(url: String): String {
        // 记录当前已重试的次数
        var lastException: Exception? = null
        // 循环尝试，最多 maxRetries 次
        repeat(maxRetries) { attempt ->
            try {
                // 委托给被装饰对象执行请求
                return wrapped.fetchData(url)
            } catch (e: Exception) {
                // 捕获异常，记录并准备下一次重试
                lastException = e
                Log.w("ApiService", "第 ${attempt + 1} 次重试失败: ${e.message}")
            }
        }
        // 所有重试都失败，抛出最后一次异常
        throw lastException ?: RuntimeException("请求失败")
    }
}

fun createApiService(enableLog: Boolean, enableCache: Boolean): ApiService {
    // 从最核心的真实服务开始
    var service: ApiService = RealApiService()
 
    // 根据配置动态决定是否添加缓存层
    if (enableCache) {
        service = CachingDecorator(service)    // 包裹一层缓存
    }
 
    // 根据配置动态决定是否添加日志层
    if (enableLog) {
        service = LoggingDecorator(service)    // 包裹一层日志
    }
 
    // 始终添加重试保护
    service = RetryDecorator(service, maxRetries = 3)  // 最外层：重试
 
    return service
}

包裹顺序（由内到外）          调用链（由外到内）
┌──────────────────────────────────────┐
│  RetryDecorator                      │  ← 最外层先拦截
│  ┌──────────────────────────────┐    │
│  │  LoggingDecorator            │    │  ← 第二层打日志
│  │  ┌──────────────────────┐    │    │
│  │  │  CachingDecorator    │    │    │  ← 第三层查缓存
│  │  │  ┌──────────────┐    │    │    │
│  │  │  │ RealApiService│   │    │    │  ← 最内层真正请求
│  │  │  └──────────────┘    │    │    │
│  │  └──────────────────────┘    │    │
│  └──────────────────────────────┘    │
└──────────────────────────────────────┘

// =============================================
// 使用 Kotlin "by" 关键字实现装饰器
// "by coffee" 自动将 Coffee 接口的所有方法委托给 coffee 对象
// 我们只需 override 想要增强的方法即可
// =============================================
class MilkDecorator(
    private val coffee: Coffee  // 被装饰对象
) : Coffee by coffee {          // 所有未 override 的方法自动委托给 coffee
 
    // 只 override 需要增强的方法
    override fun cost(): Double {
        // 在委托结果基础上加牛奶价格
        return coffee.cost() + 3.0
    }
 
    override fun description(): String {
        // 在委托结果基础上追加描述
        return "${coffee.description()} + 牛奶"
    }
}

// Java 版：必须手动覆盖所有接口方法并委托
public class MilkDecorator implements Coffee {
    // 持有被装饰对象的引用
    private final Coffee coffee;
 
    // 构造函数接收被装饰对象
    public MilkDecorator(Coffee coffee) {
        this.coffee = coffee;
    }
 
    @Override
    public double cost() {
        // 手动委托 + 增强
        return coffee.cost() + 3.0;
    }
 
    @Override
    public String description() {
        // 手动委托 + 增强
        return coffee.description() + " + 牛奶";
    }
 
    // 如果 Coffee 接口还有其他方法，必须逐个手动委托
    // @Override public xxx() { return coffee.xxx(); }
    // ... 大量模板代码
}

// =============================================
// android.content.ContextWrapper —— 典型的装饰器基类
// 源码位于 frameworks/base/core/java/android/content/ContextWrapper.java
// =============================================
public class ContextWrapper extends Context {
 
    // 持有被装饰对象的引用，这就是装饰器模式的核心
    // mBase 通常是 ContextImpl 的实例
    Context mBase;
 
    // 构造函数接收被装饰的 Context
    public ContextWrapper(Context base) {
        mBase = base;
    }
 
    // 允许后续动态替换被装饰对象（attachBaseContext 在 Activity 创建时调用）
    protected void attachBaseContext(Context base) {
        if (mBase != null) {
            throw new IllegalStateException("Base context already set");
        }
        mBase = base;  // 绑定真正的 ContextImpl
    }
 
    // ====== 以下是典型的委托方法 ======
    // 所有方法都直接委托给 mBase（被装饰者）
 
    @Override
    public Resources getResources() {
        // 委托给 mBase 获取资源
        return mBase.getResources();
    }
 
    @Override
    public ContentResolver getContentResolver() {
        // 委托给 mBase 获取 ContentResolver
        return mBase.getContentResolver();
    }
 
    @Override
    public void startActivity(Intent intent) {
        // 委托给 mBase 启动 Activity
        mBase.startActivity(intent);
    }
 
    // ... 还有上百个类似的委托方法
}

// =============================================
// android.view.ContextThemeWrapper —— 装饰器的装饰器
// 在 ContextWrapper 基础上增加了 Theme（主题）相关功能
// =============================================
public class ContextThemeWrapper extends ContextWrapper {
 
    // 新增的装饰功能：持有主题资源
    private int mThemeResource;
    private Resources.Theme mTheme;
 
    @Override
    public void setTheme(int resid) {
        // 不再委托给 mBase，而是自己管理主题
        mThemeResource = resid;
        initializeTheme();  // 初始化主题
    }
 
    @Override
    public Resources.Theme getTheme() {
        // 返回自己管理的主题，而非 mBase 的主题
        if (mTheme == null) {
            // 懒初始化
            initializeTheme();
        }
        return mTheme;  // 装饰器的增强：覆盖了主题行为
    }
 
    // 其他方法仍然通过 ContextWrapper 委托给 mBase
}

Activity                          (继承 ContextThemeWrapper)
  └── ContextThemeWrapper         (继承 ContextWrapper, 增强: Theme)
       └── ContextWrapper         (装饰器基类, 持有 mBase)
            └── mBase ──→ ContextImpl  (真正干活的组件)

// =============================================
// 自定义 ContextWrapper：给所有资源请求加上多语言支持
// =============================================
class LocaleContextWrapper(
    base: Context,                    // 被装饰的原始 Context
    private val newLocale: Locale     // 要覆盖的语言环境
) : ContextWrapper(base) {
 
    // 只 override 需要增强的方法：getResources()
    override fun getResources(): Resources {
        // 获取原始 Configuration
        val config = Configuration(super.getResources().configuration)
        // 修改语言设置
        config.setLocale(newLocale)
        // 使用新的 Configuration 创建新的 Context
        val localeContext = createConfigurationContext(config)
        // 返回新 Context 的 Resources（语言已切换）
        return localeContext.resources
    }
}
 
// 使用方式：在 Activity 的 attachBaseContext 中包裹
class MyActivity : AppCompatActivity() {
    override fun attachBaseContext(newBase: Context) {
        // 用 LocaleContextWrapper 包裹原始 Context
        val localeWrapper = LocaleContextWrapper(newBase, Locale("zh", "CN"))
        super.attachBaseContext(localeWrapper)  // 传入装饰后的 Context
    }
}

// =============================================
// java.io.FilterInputStream —— InputStream 的抽象装饰器
// =============================================
public class FilterInputStream extends InputStream {
 
    // 持有被装饰的 InputStream 引用（装饰器的核心字段）
    protected volatile InputStream in;
 
    // 构造函数接收被装饰的流
    protected FilterInputStream(InputStream in) {
        this.in = in;
    }
 
    // 所有 read 方法都委托给被装饰对象
    public int read() throws IOException {
        return in.read();  // 纯粹的委托
    }
 
    public int read(byte[] b, int off, int len) throws IOException {
        return in.read(b, off, len);  // 纯粹的委托
    }
 
    public void close() throws IOException {
        in.close();  // 关闭时也委托
    }
}

// =============================================
// java.io.BufferedInputStream —— 缓冲装饰器
// 核心增强：引入内部缓冲区，减少实际 I/O 次数
// =============================================
public class BufferedInputStream extends FilterInputStream {
 
    // 内部缓冲区（装饰器新增的功能）
    protected volatile byte[] buf;
    // 缓冲区中有效字节的数量
    protected int count;
    // 当前读取位置
    protected int pos;
 
    // 构造函数：指定缓冲区大小
    public BufferedInputStream(InputStream in, int size) {
        super(in);                    // 调用父类构造，保存被装饰对象
        buf = new byte[size];         // 创建缓冲区
    }
 
    @Override
    public synchronized int read() throws IOException {
        // 增强逻辑：先检查缓冲区是否有数据
        if (pos >= count) {
            // 缓冲区已空，从被装饰流中批量读取数据填充缓冲区
            fill();  // 一次性读取大量数据到 buf 中
            if (pos >= count) {
                return -1;  // 流结束
            }
        }
        // 从缓冲区中返回一个字节（极快，无需真实 I/O）
        return buf[pos++] & 0xff;
    }
}

// =============================================
// 在 Android 中读取 assets 中的 GZIP 压缩 JSON 文件
// 展示装饰器的层层嵌套
// =============================================
fun readCompressedJson(context: Context): String {
    // 最内层：从 assets 打开原始字节流
    val rawStream: InputStream = context.assets.open("data.json.gz")
 
    // 第1层装饰：添加 GZIP 解压能力
    val gzipStream = GZIPInputStream(rawStream)
 
    // 第2层装饰：添加缓冲能力（减少 I/O 次数，提升性能）
    val bufferedStream = BufferedInputStream(gzipStream, 8192)
 
    // 第3层装饰：添加字符解码能力（byte → char）
    val reader = InputStreamReader(bufferedStream, Charsets.UTF_8)
 
    // 第4层装饰：添加按行读取能力
    val bufferedReader = BufferedReader(reader)
 
    // 使用 Kotlin 的 use 扩展函数（自动关闭流，等同于 try-with-resources）
    return bufferedReader.use { it.readText() }
}

// Kotlin 提供了更优雅的链式写法，但底层仍然是装饰器模式
fun readCompressedJsonKotlin(context: Context): String =
    context.assets.open("data.json.gz")  // 原始流
        .let(::GZIPInputStream)          // 装饰: 解压
        .bufferedReader(Charsets.UTF_8)   // 装饰: 缓冲 + 字符解码
        .use { it.readText() }           // 读取全部内容并自动关闭

// === 定义统一接口：无论代理还是真实对象，对外暴露相同的契约 ===
interface ImageLoader {
    fun loadImage(url: String): Bitmap  // 加载图片
}
 
// === 真实对象：直接执行昂贵的网络请求 ===
class RealImageLoader : ImageLoader {
    override fun loadImage(url: String): Bitmap {
        // 真正去网络下载图片（耗时操作）
        println("正在从网络下载: $url")
        return downloadFromNetwork(url)  // 实际下载逻辑
    }
}
 
// === 代理对象：在访问真实对象之前/之后施加控制 ===
class ImageLoaderProxy(
    private val realLoader: RealImageLoader  // 持有真实对象的引用
) : ImageLoader {
 
    // 缓存已加载的图片，避免重复下载
    private val cache = mutableMapOf<String, Bitmap>()
 
    override fun loadImage(url: String): Bitmap {
        // 【控制点1】先检查缓存
        cache[url]?.let {
            println("命中缓存: $url")
            return it               // 有缓存直接返回，不访问真实对象
        }
        // 【控制点2】缓存未命中，委托给真实对象
        val bitmap = realLoader.loadImage(url)
        // 【控制点3】将结果存入缓存
        cache[url] = bitmap
        return bitmap
    }
}

// Client 代码：完全不知道自己在使用代理
fun displayImage(loader: ImageLoader) {  // 依赖接口，不依赖具体类
    val bitmap = loader.loadImage("https://example.com/photo.jpg")
    imageView.setImageBitmap(bitmap)      // 直接使用返回值
}

// ========== 1. 定义 Subject 接口 ==========
interface IUserService {
    fun login(username: String, password: String): Boolean   // 登录
    fun getUserInfo(userId: String): User                    // 获取用户信息
}
 
// ========== 2. 真实实现类 (RealSubject) ==========
class RealUserService : IUserService {
 
    override fun login(username: String, password: String): Boolean {
        // 模拟真正的登录逻辑：查询数据库、校验密码等
        println("RealUserService: 正在验证用户 $username")
        return username == "admin" && password == "123456"   // 简化逻辑
    }
 
    override fun getUserInfo(userId: String): User {
        // 模拟真正的查询逻辑
        println("RealUserService: 正在查询用户 $userId 的信息")
        return User(userId, "张三", "zhangsan@example.com")  // 返回模拟数据
    }
}
 
// ========== 3. 代理类 (Proxy) — 编译期就写好的，所以叫"静态" ==========
class UserServiceProxy(
    private val realService: IUserService   // 通过构造器注入真实对象（对象适配器的组合思想）
) : IUserService {
 
    private val tag = "UserServiceProxy"    // 日志标签
 
    override fun login(username: String, password: String): Boolean {
        // === 前置增强 (Before) ===
        println("$tag: [Before] login() 被调用, username=$username")
        val startTime = System.currentTimeMillis()              // 记录开始时间
 
        // === 委托给真实对象 ===
        val result = realService.login(username, password)      // 核心：转发调用
 
        // === 后置增强 (After) ===
        val elapsed = System.currentTimeMillis() - startTime    // 计算耗时
        println("$tag: [After] login() 返回 $result, 耗时 ${elapsed}ms")
        return result                                           // 将真实结果返回给 Client
    }
 
    override fun getUserInfo(userId: String): User {
        // === 前置增强：权限检查 ===
        println("$tag: [Before] 正在检查权限...")
        if (!checkPermission()) {                               // 保护代理：权限不足则拒绝
            throw SecurityException("无权访问用户信息")
        }
 
        // === 委托给真实对象 ===
        val user = realService.getUserInfo(userId)              // 转发调用
 
        // === 后置增强：脱敏处理 ===
        println("$tag: [After] 对返回数据进行脱敏")
        return user.copy(email = "***@***.com")                 // 返回脱敏后的数据
    }
 
    private fun checkPermission(): Boolean = true               // 简化的权限检查
}
 
// ========== 4. Client 调用 ==========
fun main() {
    // Client 只依赖接口，不关心背后是代理还是真实对象
    val service: IUserService = UserServiceProxy(RealUserService())
    
    val loginResult = service.login("admin", "123456")    // 通过代理调用
    println("登录结果: $loginResult")
    
    val user = service.getUserInfo("1001")                // 通过代理调用
    println("用户信息: $user")
}

// Proxy.newProxyInstance 方法签名
public static Object newProxyInstance(
    ClassLoader loader,          // 类加载器，通常使用接口的 ClassLoader
    Class<?>[] interfaces,       // 要代理的接口数组（可同时代理多个接口）
    InvocationHandler handler    // 调用处理器，所有方法调用都会转发到这里
)

public interface InvocationHandler {
    /**
     * @param proxy  动态生成的代理对象本身（注意：不是真实对象！）
     * @param method 当前被调用的方法的 Method 对象
     * @param args   方法参数数组
     * @return       方法的返回值
     */
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

import java.lang.reflect.InvocationHandler
import java.lang.reflect.Method
import java.lang.reflect.Proxy
 
// ========== 1. 定义接口（与静态代理一样） ==========
interface IUserService {
    fun login(username: String, password: String): Boolean
    fun getUserInfo(userId: String): User
}
 
interface IOrderService {
    fun createOrder(productId: String, quantity: Int): String
}
 
// ========== 2. 真实实现类（与静态代理一样） ==========
class RealUserService : IUserService {
    override fun login(username: String, password: String): Boolean {
        println("RealUserService: 验证用户 $username")
        return username == "admin" && password == "123456"
    }
 
    override fun getUserInfo(userId: String): User {
        println("RealUserService: 查询用户 $userId")
        return User(userId, "张三", "zhangsan@example.com")
    }
}
 
class RealOrderService : IOrderService {
    override fun createOrder(productId: String, quantity: Int): String {
        println("RealOrderService: 创建订单, 商品=$productId, 数量=$quantity")
        return "ORDER-${System.currentTimeMillis()}"   // 返回订单号
    }
}
 
// ========== 3. 通用 InvocationHandler（核心！一个 Handler 搞定所有接口） ==========
class LoggingInvocationHandler(
    private val target: Any       // 真实目标对象（注意类型是 Any，通用）
) : InvocationHandler {
 
    /**
     * 每当 Client 调用代理对象的任何方法时，JVM 都会把调用转发到这里。
     * 
     * @param proxy  JVM 动态生成的代理对象（$Proxy0 实例）
     * @param method 被调用的具体方法（如 login、getUserInfo）
     * @param args   方法参数数组（可能为 null，如无参方法）
     */
    override fun invoke(proxy: Any?, method: Method, args: Array<out Any>?): Any? {
        // === 前置增强 ===
        val methodName = method.name                                  // 获取方法名
        val paramStr = args?.joinToString() ?: "无参数"               // 拼接参数字符串
        println("┌─ [Proxy] 拦截方法: $methodName($paramStr)")
        val startTime = System.nanoTime()                             // 纳秒级计时
 
        // === 核心：反射调用真实对象的方法 ===
        // 注意这里传的是 target（真实对象），不是 proxy！
        val result = method.invoke(target, *(args ?: emptyArray()))   // 解构参数数组
 
        // === 后置增强 ===
        val elapsed = (System.nanoTime() - startTime) / 1_000_000.0  // 转为毫秒
        println("└─ [Proxy] $methodName() 返回: $result, 耗时: ${elapsed}ms")
 
        return result                                                 // 将真实返回值透传给 Client
    }
}
 
// ========== 4. 动态代理工厂函数 ==========
// 使用 Kotlin 的 reified 泛型 + inline 简化创建过程
@Suppress("UNCHECKED_CAST")
inline fun <reified T> createProxy(target: T): T {
    return Proxy.newProxyInstance(
        T::class.java.classLoader,                    // 使用接口 T 的 ClassLoader
        arrayOf(T::class.java),                       // 代理的接口数组（这里只代理一个接口）
        LoggingInvocationHandler(target as Any)        // 将 target 包装到 Handler 中
    ) as T                                            // 强制转型为接口类型 T
}
 
// ========== 5. Client 使用 ==========
fun main() {
    // 创建 IUserService 的动态代理（无需手写 UserServiceProxy 类！）
    val userService: IUserService = createProxy<IUserService>(RealUserService())
    userService.login("admin", "123456")
    userService.getUserInfo("1001")
 
    println("─".repeat(50))
 
    // 同一个 Handler 类，也能代理 IOrderService（无需额外编写代理类！）
    val orderService: IOrderService = createProxy<IOrderService>(RealOrderService())
    orderService.createOrder("PROD-001", 3)
}

┌─ [Proxy] 拦截方法: login(admin, 123456)
RealUserService: 验证用户 admin
└─ [Proxy] login() 返回: true, 耗时: 0.85ms
┌─ [Proxy] 拦截方法: getUserInfo(1001)
RealUserService: 查询用户 1001
└─ [Proxy] getUserInfo() 返回: User(id=1001, name=张三, ...), 耗时: 0.12ms
──────────────────────────────────────────────────
┌─ [Proxy] 拦截方法: createOrder(PROD-001, 3)
RealOrderService: 创建订单, 商品=PROD-001, 数量=3
└─ [Proxy] createOrder() 返回: ORDER-1709312345678, 耗时: 0.09ms

// JVM 在运行时动态生成的代理类（伪反编译，简化表示）
final class $Proxy0 extends Proxy implements IUserService {
 
    // 静态字段：缓存 Method 对象，避免每次反射查找
    private static Method m_login;        // login 方法的 Method 对象
    private static Method m_getUserInfo;  // getUserInfo 方法的 Method 对象
 
    static {
        try {
            // 类加载时通过反射获取 Method 对象并缓存
            m_login = IUserService.class.getMethod(
                "login", String.class, String.class
            );
            m_getUserInfo = IUserService.class.getMethod(
                "getUserInfo", String.class
            );
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        }
    }
 
    // 构造函数接收 InvocationHandler
    $Proxy0(InvocationHandler handler) {
        super(handler);  // Proxy 基类持有 handler 引用（字段名为 h）
    }
 
    // 实现接口方法：所有调用都转发到 handler.invoke()
    @Override
    public boolean login(String username, String password) {
        try {
            // 调用 handler 的 invoke 方法
            // this = 代理对象本身
            // m_login = 当前被调用的 Method
            // new Object[]{username, password} = 参数数组
            return (Boolean) this.h.invoke(this, m_login,
                new Object[]{username, password});
        } catch (Throwable t) {
            throw new UndeclaredThrowableException(t);
        }
    }
 
    @Override
    public User getUserInfo(String userId) {
        try {
            return (User) this.h.invoke(this, m_getUserInfo,
                new Object[]{userId});
        } catch (Throwable t) {
            throw new UndeclaredThrowableException(t);
        }
    }
}

// ========== AIDL 自动生成的接口和 Stub/Proxy（大幅简化） ==========
 
// Subject 接口
public interface IMyService extends IInterface {
    String getData(int id) throws RemoteException;   // 业务方法声明
 
    // ========== Stub：服务端骨架（RealSubject 的基类） ==========
    abstract class Stub extends Binder implements IMyService {
 
        private static final String DESCRIPTOR = "com.example.IMyService";  // 唯一标识
        private static final int TRANSACTION_getData = FIRST_CALL_TRANSACTION;  // 方法编号
 
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);  // 注册到 Binder 框架
        }
 
        /**
         * 关键方法：判断 binder 是本地还是远程
         * 本地 → 直接返回 Stub（无需代理）
         * 远程 → 返回 Proxy 包装
         */
        public static IMyService asInterface(IBinder obj) {
            if (obj == null) return null;                    // 空检查
            // 尝试查找本地接口（同进程优化）
            IInterface localInterface = obj.queryLocalInterface(DESCRIPTOR);
            if (localInterface instanceof IMyService) {
                return (IMyService) localInterface;          // 同进程：直接返回，无代理开销
            }
            return new Proxy(obj);                           // 跨进程：返回代理对象
        }
 
        @Override
        protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) {
            switch (code) {
                case TRANSACTION_getData: {
                    data.enforceInterface(DESCRIPTOR);       // 安全校验
                    int id = data.readInt();                  // 从 Parcel 反序列化参数
                    String result = this.getData(id);        // 调用真实实现
                    reply.writeNoException();                 // 写入无异常标记
                    reply.writeString(result);                // 序列化返回值
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }
 
        // ========== Proxy：客户端代理 ==========
        private static class Proxy implements IMyService {
            private IBinder remote;                          // 持有远程 Binder 引用
 
            Proxy(IBinder remote) {
                this.remote = remote;                        // 保存远程引用
            }
 
            @Override
            public String getData(int id) throws RemoteException {
                Parcel data = Parcel.obtain();               // 获取输入 Parcel
                Parcel reply = Parcel.obtain();              // 获取输出 Parcel
                try {
                    data.writeInterfaceToken(DESCRIPTOR);    // 写入接口标识
                    data.writeInt(id);                       // 序列化方法参数
                    // 核心：通过 Binder 驱动发起跨进程调用
                    remote.transact(TRANSACTION_getData, data, reply, 0);
                    reply.readException();                   // 检查远程是否有异常
                    return reply.readString();               // 反序列化返回值
                } finally {
                    data.recycle();                          // 回收 Parcel 防止内存泄漏
                    reply.recycle();
                }
            }
 
            @Override
            public IBinder asBinder() {
                return remote;                               // 返回底层 IBinder
            }
        }
    }
}

// ========== 1. 定义 API 接口（只是一个接口，没有任何实现！） ==========
interface GitHubApi {
    @GET("users/{user}/repos")                              // HTTP 注解声明请求方式和路径
    suspend fun listRepos(
        @Path("user") user: String                          // 路径参数
    ): List<Repo>
 
    @POST("repos/{owner}/{repo}/issues")                    // POST 请求
    suspend fun createIssue(
        @Path("owner") owner: String,                       // 路径参数
        @Path("repo") repo: String,                         // 路径参数
        @Body issue: CreateIssueRequest                     // 请求体
    ): Issue
}
 
// ========== 2. 创建 Retrofit 实例并生成代理对象 ==========
val retrofit = Retrofit.Builder()
    .baseUrl("https://api.github.com/")                     // 基础 URL
    .addConverterFactory(GsonConverterFactory.create())     // JSON 转换器
    .build()
 
// 🔥 核心：这一行就是动态代理！
// Retrofit.create() 内部调用 Proxy.newProxyInstance()
val api: GitHubApi = retrofit.create(GitHubApi::class.java)
 
// ========== 3. 使用代理对象发起网络请求 ==========
// api 并不是某个具体的 GitHubApi 实现类，而是 JVM 生成的 $Proxy0 对象！
val repos = api.listRepos("JakeWharton")                    // 自动生成 HTTP GET 请求

// Retrofit.java 核心源码（简化）
public <T> T create(final Class<T> service) {
    // 1. 校验：必须是接口
    validateServiceInterface(service);
 
    // 2. 动态代理！关键就这一步
    return (T) Proxy.newProxyInstance(
        service.getClassLoader(),              // 使用接口的 ClassLoader
        new Class<?>[]{service},               // 代理的接口数组
        new InvocationHandler() {              // 匿名 InvocationHandler
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
 
                // 3. 跳过 Object 类的方法（toString、equals 等）
                if (method.getDeclaringClass() == Object.class) {
                    return method.invoke(this, args);          // 直接调用，不代理
                }
 
                // 4. 解析方法上的注解（@GET、@POST、@Path、@Body 等）
                //    并缓存为 ServiceMethod 对象
                ServiceMethod<?> serviceMethod = loadServiceMethod(method);
 
                // 5. 根据注解信息构建 OkHttp 的 Request 并执行
                //    将返回值转换为用户期望的类型（如 List<Repo>）
                return serviceMethod.invoke(args);
            }
        }
    );
}

import java.lang.reflect.InvocationHandler
import java.lang.reflect.Method
import java.lang.reflect.Proxy
 
// ========== 自定义注解 ==========
@Target(AnnotationTarget.FUNCTION)                // 只能标注在方法上
@Retention(AnnotationRetention.RUNTIME)           // 运行时保留（反射可读取）
annotation class GET(val path: String)            // GET 请求注解
 
@Target(AnnotationTarget.VALUE_PARAMETER)         // 只能标注在参数上
@Retention(AnnotationRetention.RUNTIME)
annotation class Path(val value: String)          // 路径参数注解
 
// ========== 定义 API 接口 ==========
interface SimpleApi {
    @GET("/users/{id}/profile")                   // 注解声明请求路径
    fun getUserProfile(@Path("id") userId: String): String
}
 
// ========== 迷你版 Retrofit ==========
class MiniRetrofit(private val baseUrl: String) {
 
    // 核心方法：创建接口的动态代理实现
    @Suppress("UNCHECKED_CAST")
    fun <T> create(serviceClass: Class<T>): T {
        return Proxy.newProxyInstance(
            serviceClass.classLoader,                          // ClassLoader
            arrayOf(serviceClass),                             // 代理接口
            object : InvocationHandler {                       // 匿名 InvocationHandler
                override fun invoke(proxy: Any?, method: Method, args: Array<out Any>?): Any? {
                    // --- Step 1: 获取方法上的 @GET 注解 ---
                    val getAnnotation = method.getAnnotation(GET::class.java)
                        ?: throw IllegalStateException("方法 ${method.name} 缺少 @GET 注解")
 
                    var path = getAnnotation.path               // 获取原始路径模板
 
                    // --- Step 2: 解析参数上的 @Path 注解，替换路径占位符 ---
                    val parameters = method.parameters          // 获取参数列表
                    parameters.forEachIndexed { index, param ->
                        val pathAnnotation = param.getAnnotation(Path::class.java)
                        if (pathAnnotation != null) {
                            val placeholder = "{${pathAnnotation.value}}"  // 如 {id}
                            val actualValue = args?.get(index)?.toString() ?: ""
                            path = path.replace(placeholder, actualValue) // 替换为实际值
                        }
                    }
 
                    // --- Step 3: 构建完整 URL 并"发送请求" ---
                    val fullUrl = "$baseUrl$path"
                    println("🌐 GET $fullUrl")                  // 模拟发送 HTTP 请求
 
                    // --- Step 4: 返回模拟响应 ---
                    return """{"id": "${args?.get(0)}", "name": "MiniRetrofit User"}"""
                }
            }
        ) as T
    }
}
 
// ========== 使用 ==========
fun main() {
    val miniRetrofit = MiniRetrofit("https://api.example.com")
 
    // 创建代理对象（无需手写 SimpleApi 的实现类！）
    val api: SimpleApi = miniRetrofit.create(SimpleApi::class.java)
 
    // 调用接口方法 → 自动触发 InvocationHandler.invoke()
    val result = api.getUserProfile("42")
    println("响应: $result")
}
// 输出：
// 🌐 GET https://api.example.com/users/42/profile
// 响应: {"id": "42", "name": "MiniRetrofit User"}

// Native 层的 Binder 代理结构（简化示意）
 
// ===== 接口层 =====
class IMyService : public IInterface {               // Subject 接口
public:
    DECLARE_META_INTERFACE(MyService);                // 宏展开：定义 descriptor 等
    virtual status_t getData(int id, String* out) = 0; // 纯虚函数 = 接口方法
};
 
// ===== 代理端 (Client 进程) =====
class BpMyService : public BpInterface<IMyService> {  // Bp = Binder Proxy
public:
    explicit BpMyService(const sp<IBinder>& impl)
        : BpInterface<IMyService>(impl) {}            // 持有远程 IBinder
 
    virtual status_t getData(int id, String* out) {
        Parcel data, reply;                           // 序列化容器
        data.writeInterfaceToken(                     // 写入接口标识
            IMyService::getInterfaceDescriptor());
        data.writeInt32(id);                          // 序列化参数
        // 通过 Binder 驱动跨进程调用
        remote()->transact(GET_DATA, data, &reply);   // remote() 返回 BpBinder
        *out = reply.readString16();                  // 反序列化返回值
        return reply.readInt32();                     // 返回状态码
    }
};
 
// ===== 服务端 (Server 进程) =====
class BnMyService : public BnInterface<IMyService> {  // Bn = Binder Native
public:
    virtual status_t onTransact(uint32_t code,
            const Parcel& data, Parcel* reply, uint32_t flags) {
        switch (code) {
            case GET_DATA: {
                CHECK_INTERFACE(IMyService, data, reply); // 安全校验
                int id = data.readInt32();                // 反序列化参数
                String result;
                status_t status = getData(id, &result);   // 调用真实实现
                reply->writeString16(result);             // 序列化返回值
                reply->writeInt32(status);
                return NO_ERROR;
            }
        }
        return BBinder::onTransact(code, data, reply, flags);
    }
};

// ====== 子系统 A：灯光控制 ======
class LightSystem {
    // 关闭所有灯光
    fun turnOffAll() {
        println("LightSystem: 所有灯光已关闭")
    }
}
 
// ====== 子系统 B：空调控制 ======
class AirConditionerSystem {
    // 关闭空调
    fun shutdown() {
        println("AirConditionerSystem: 空调已关闭")
    }
}
 
// ====== 子系统 C：门锁控制 ======
class DoorLockSystem {
    // 锁定大门
    fun lockAll() {
        println("DoorLockSystem: 所有门已锁定")
    }
}
 
// ====== 子系统 D：安防系统 ======
class SecuritySystem {
    // 启动安防摄像头
    fun armCameras() {
        println("SecuritySystem: 安防摄像头已启动")
    }
}

fun main() {
    // 客户端必须知道每一个子系统的存在和调用顺序
    val lights = LightSystem()          // 直接依赖子系统 A
    val ac = AirConditionerSystem()     // 直接依赖子系统 B
    val door = DoorLockSystem()         // 直接依赖子系统 C
    val security = SecuritySystem()     // 直接依赖子系统 D
 
    // 离家操作：必须按顺序手动调用
    lights.turnOffAll()
    ac.shutdown()
    door.lockAll()
    security.armCameras()
}

// ====== 外观类：智能家居控制中心 ======
class SmartHomeFacade(
    // 通过构造函数注入所有子系统（组合关系）
    private val lights: LightSystem = LightSystem(),
    private val ac: AirConditionerSystem = AirConditionerSystem(),
    private val door: DoorLockSystem = DoorLockSystem(),
    private val security: SecuritySystem = SecuritySystem()
) {
    /**
     * 一键离家：封装了对多个子系统的有序调用
     * 客户端无需了解内部有哪些子系统，也不需要关心调用顺序
     */
    fun leaveHome() {
        println("=== 执行离家模式 ===")
        lights.turnOffAll()       // 第一步：关灯
        ac.shutdown()             // 第二步：关空调
        door.lockAll()            // 第三步：锁门
        security.armCameras()     // 第四步：启动安防
        println("=== 离家模式完成 ===")
    }
 
    /**
     * 一键回家：反向操作
     */
    fun arriveHome() {
        println("=== 执行回家模式 ===")
        security.disarmCameras()  // 先关闭安防（假设有此方法）
        door.unlockMain()         // 解锁大门
        lights.turnOnLiving()     // 打开客厅灯
        ac.startCooling(26)       // 空调制冷 26°C
        println("=== 回家模式完成 ===")
    }
}

fun main() {
    // 客户端只依赖 Facade 一个类
    val home = SmartHomeFacade()
 
    // 一行代码完成复杂操作
    home.leaveHome()
 
    // 之后回家
    home.arriveHome()
}

// ====== payment-api 模块：只定义接口（暴露给外部） ======
interface PaymentFacade {
    /**
     * 一键完成支付流程
     * @param orderId 订单 ID
     * @param amount  金额（单位：分）
     * @return 支付结果
     */
    suspend fun processPayment(orderId: String, amount: Long): PaymentResult
 
    /**
     * 查询支付状态
     */
    suspend fun queryStatus(transactionId: String): PaymentStatus
}
 
// 支付结果密封类
sealed class PaymentResult {
    data class Success(val transactionId: String) : PaymentResult()  // 成功
    data class Failure(val errorCode: Int, val message: String) : PaymentResult()  // 失败
}

// ====== payment-impl 模块：实现 Facade，编排内部子系统 ======
class PaymentFacadeImpl(
    private val validator: OrderValidator,         // 子系统1：订单校验
    private val gateway: PaymentGateway,           // 子系统2：支付网关
    private val receiptGen: ReceiptGenerator,      // 子系统3：收据生成
    private val logger: TransactionLogger          // 子系统4：交易日志
) : PaymentFacade {
 
    override suspend fun processPayment(orderId: String, amount: Long): PaymentResult {
        // 第一步：校验订单合法性
        val order = validator.validate(orderId)
            ?: return PaymentResult.Failure(1001, "订单不存在或已失效")
 
        // 第二步：调用支付网关扣款
        val transaction = gateway.charge(order, amount)
        if (!transaction.isSuccess) {
            // 扣款失败，记录日志并返回
            logger.logFailure(orderId, transaction.errorMsg)
            return PaymentResult.Failure(transaction.errorCode, transaction.errorMsg)
        }
 
        // 第三步：生成电子收据
        receiptGen.generate(transaction.id, order, amount)
 
        // 第四步：记录成功日志
        logger.logSuccess(transaction.id, orderId, amount)
 
        // 返回成功结果
        return PaymentResult.Success(transaction.id)
    }
 
    override suspend fun queryStatus(transactionId: String): PaymentStatus {
        // 委托给支付网关查询
        return gateway.queryTransaction(transactionId)
    }
}