设计模式是构建高质量Android应用的重要工具。本文将全面介绍Android开发中最常用的7种结构型设计模式，包括它们的核心概念、典型应用场景以及实际代码示例。

一、结构型模式概述

结构型模式主要解决如何组合类和对象以获得更大结构的问題。在Android开发中，这些模式帮助我们：

• 构建灵活的UI组件体系

• 优化数据与视图的交互

• 简化复杂系统的接口

• 提高代码复用性和可维护性

二、7种核心结构型模式详解

1. 适配器模式 (Adapter)

模式定义：将一个接口转换成客户端期望的另一个接口，解决接口不兼容问题。

Android典型实现：

// 自定义RecyclerView适配器
class MovieAdapter(
    private val movies: List<Movie>,
    private val listener: (Movie) -> Unit
) : RecyclerView.Adapter<MovieAdapter.ViewHolder>() {

    inner class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
        private val title: TextView = view.findViewById(R.id.tvTitle)
        private val poster: ImageView = view.findViewById(R.id.ivPoster)

        fun bind(movie: Movie) {
            title.text = movie.title
            Glide.with(itemView).load(movie.posterUrl).into(poster)
            itemView.setOnClickListener { listener(movie) }
        }
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_movie, parent, false)
        return ViewHolder(view)
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        holder.bind(movies[position])
    }

    override fun getItemCount() = movies.size
}

应用场景：

• RecyclerView/ListView适配器

• 连接不同数据源与UI组件

• 第三方库接口适配

优势分析：

• 解耦数据源和显示逻辑

• 支持多种数据类型展示

• 符合单一职责原则

2. 桥接模式 (Bridge)

模式定义：将抽象部分与实现部分分离，使它们可以独立变化。

Android实现示例：

// 抽象部分
interface ViewRenderer {
    fun render(view: View)
}

// 具体实现A
class DarkThemeRenderer : ViewRenderer {
    override fun render(view: View) {
        view.setBackgroundColor(Color.BLACK)
        if (view is TextView) {
            view.setTextColor(Color.WHITE)
        }
    }
}

// 具体实现B
class LightThemeRenderer : ViewRenderer {
    override fun render(view: View) {
        view.setBackgroundColor(Color.WHITE)
        if (view is TextView) {
            view.setTextColor(Color.BLACK)
        }
    }
}

// 抽象控件基类
abstract class ThemedView(context: Context) : View(context) {
    protected var renderer: ViewRenderer? = null
    
    fun setRenderer(renderer: ViewRenderer) {
        this.renderer = renderer
        invalidate()
    }
    
    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        renderer?.render(this)
    }
}

// 使用示例
val darkButton = ThemedButton(context).apply {
    setRenderer(DarkThemeRenderer())
}

典型场景：

• 主题切换系统

• 跨平台UI渲染

• 多种表现形式的控件

模式优势：

• 抽象与实现解耦

• 避免多层继承

• 运行时切换实现

3. 组合模式 (Composite)

模式定义：将对象组合成树形结构以表示"部分-整体"的层次结构。

Android视图体系应用：

// 组件接口
interface UIComponent {
    fun draw(canvas: Canvas)
    val bounds: Rect
}

// 叶子节点
class CircleComponent(
    override val bounds: Rect,
    private val color: Int
) : UIComponent {
    override fun draw(canvas: Canvas) {
        Paint().apply {
            this.color = color
            canvas.drawCircle(
                bounds.exactCenterX(),
                bounds.exactCenterY(),
                bounds.width() / 2f,
                this
            )
        }
    }
}

// 复合组件
class PanelComponent(
    override val bounds: Rect,
    private val bgColor: Int
) : UIComponent {
    private val children = mutableListOf<UIComponent>()
    
    fun addComponent(component: UIComponent) {
        children.add(component)
    }
    
    override fun draw(canvas: Canvas) {
        // 绘制背景
        Paint().apply {
            this.color = bgColor
            canvas.drawRect(bounds, this)
        }
        
        // 绘制子组件
        canvas.save()
        canvas.translate(bounds.left.toFloat(), bounds.top.toFloat())
        children.forEach { it.draw(canvas) }
        canvas.restore()
    }
}

应用场景：

• View/ViewGroup体系

• 复杂菜单系统

• 嵌套的可绘制对象

优势特点：

• 统一处理简单和复杂元素

• 灵活的动态结构

• 简化客户端代码

4. 装饰器模式 (Decorator)

模式定义：动态地给对象添加额外职责，比继承更灵活。

Android Context应用：

// 基础组件
interface DataFetcher {
    fun fetchData(): String
}

// 具体实现
class NetworkFetcher : DataFetcher {
    override fun fetchData(): String {
        return "Data from network"
    }
}

// 装饰器基类
abstract class DataFetcherDecorator(
    private val wrappee: DataFetcher
) : DataFetcher {
    override fun fetchData(): String {
        return wrappee.fetchData()
    }
}

// 具体装饰器 - 缓存
class CachingDecorator(
    wrappee: DataFetcher,
    private val cache: Cache
) : DataFetcherDecorator(wrappee) {
    override fun fetchData(): String {
        val cached = cache.get("data")
        return cached ?: super.fetchData().also { 
            cache.put("data", it) 
        }
    }
}

// 具体装饰器 - 日志
class LoggingDecorator(
    wrappee: DataFetcher,
    private val logger: Logger
) : DataFetcherDecorator(wrappee) {
    override fun fetchData(): String {
        logger.log("Fetching data...")
        return super.fetchData().also {
            logger.log("Data fetched: $it")
        }
    }
}

// 使用示例
val fetcher: DataFetcher = LoggingDecorator(
    CachingDecorator(
        NetworkFetcher(),
        MemoryCache()
    ),
    ConsoleLogger()
)

典型应用：

• ContextWrapper扩展

• I/O流处理

• 动态功能添加

模式优势：

• 运行时动态扩展

• 避免子类爆炸

• 符合开闭原则

5. 外观模式 (Facade)

模式定义：为子系统提供统一的简化接口。

Android相机API封装：

class CameraSystemFacade(
    private val context: Context
) {
    private val cameraManager: CameraManager by lazy {
        context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
    }
    private val executor: Executor = Executors.newSingleThreadExecutor()
    
    fun takePhoto(
        cameraId: String,
        onSuccess: (Bitmap) -> Unit,
        onError: (Exception) -> Unit
    ) {
        try {
            cameraManager.openCamera(cameraId, object : CameraDevice.StateCallback() {
                override fun onOpened(camera: CameraDevice) {
                    // 创建会话、配置参数、捕获图像等复杂逻辑
                    // 简化为示例:
                    val image = createDummyBitmap()
                    onSuccess(image)
                }
                
                override fun onError(camera: CameraDevice, error: Int) {
                    onError(RuntimeException("Camera error: $error"))
                }
            }, null)
        } catch (e: Exception) {
            onError(e)
        }
    }
    
    private fun createDummyBitmap(): Bitmap {
        return Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888).apply {
            eraseColor(Color.RED)
        }
    }
}

// 使用示例
val cameraFacade = CameraSystemFacade(context)
cameraFacade.takePhoto(
    cameraId = "0",
    onSuccess = { bitmap -> 
        imageView.setImageBitmap(bitmap) 
    },
    onError = { e -> 
        Toast.makeText(context, "Error: ${e.message}", Toast.LENGTH_SHORT).show()
    }
)

应用场景：

• 复杂SDK封装

• 多系统服务整合

• 业务逻辑简化

优势分析：

• 简化客户端使用

• 降低子系统耦合

• 提高安全性

6. 享元模式 (Flyweight)

模式定义：运用共享技术有效支持大量细粒度对象。

Android Message复用：

class MessageFactory {
    companion object {
        private val messagePool = mutableMapOf<Int, Message>()
        
        fun obtainMessage(what: Int): Message {
            return messagePool[what]?.also { 
                it.recycle() 
            } ?: Message.obtain().apply {
                this.what = what
                messagePool[what] = this
            }
        }
    }
}

// 使用示例
val msg1 = MessageFactory.obtainMessage(1).apply {
    arg1 = 100
}
val msg2 = MessageFactory.obtainMessage(1).apply {
    arg2 = 200
}
// msg1和msg2共享相同的what值但可携带不同数据

典型应用：

• Handler消息池

• 重复View的复用

• 常量对象共享

模式优势：

• 减少内存占用

• 提高性能

• 集中管理共享状态

7. 代理模式 (Proxy)

模式定义：为其他对象提供一种代理以控制对这个对象的访问。

Android Binder代理示例：

// 服务接口
interface IRemoteService : IInterface {
    fun getData(): String
}

// 真实服务实现
class RemoteService : Binder(), IRemoteService {
    override fun asBinder() = this
    
    override fun getData(): String {
        return "Real data from service"
    }
    
    override fun getInterfaceDescriptor() = DESCRIPTOR
    
    companion object {
        const val DESCRIPTOR = "com.example.IRemoteService"
    }
}

// 代理实现
class RemoteServiceProxy(
    private val remote: IBinder
) : IRemoteService {
    override fun asBinder() = remote
    
    override fun getData(): String {
        val data = Parcel.obtain()
        val reply = Parcel.obtain()
        return try {
            remote.transact(TRANSACTION_getData, data, reply, 0)
            reply.readString() ?: ""
        } finally {
            data.recycle()
            reply.recycle()
        }
    }
    
    companion object {
        const val TRANSACTION_getData = IBinder.FIRST_CALL_TRANSACTION
    }
}

// 使用示例
val realService = RemoteService()
val proxy = RemoteServiceProxy(realService)
val data = proxy.getData() // 通过代理访问

应用场景：

• AIDL接口代理

• 图片懒加载

• 权限控制

优势特点：

• 控制对象访问

• 实现延迟加载

• 添加额外逻辑

三、结构型模式对比与选择指南

模式名称	适用场景	主要优点	Android典型应用
适配器	接口转换	兼容性高	RecyclerView.Adapter
桥接	多维度变化	解耦抽象与实现	主题系统
组合	部分-整体结构	统一处理	View/ViewGroup
装饰器	动态扩展	灵活扩展	ContextWrapper
外观	复杂子系统	简化接口	第三方SDK封装
享元	大量细粒度对象	节省资源	Message.obtain()
代理	访问控制	增强控制	AIDL接口

四、Android开发中的最佳实践

记住，模式是解决问题的工具而非目标。在实际开发中，应根据具体需求选择最合适的模式，必要时可以组合多种模式使用。随着Android平台的演进，这些经典设计模式仍然保持着强大的生命力，但实现方式可能会不断优化更新。

思考题：在你的Android项目中，哪些地方可以应用这些结构型模式来改进现有架构？如何平衡模式的使用与代码的简洁性？

1. 优先使用组合而非继承：

   // 优于继承的做法
   class CustomView(context: Context) : View(context) {
       private val decorator = ViewDecorator(this)
       
       fun addDecoration() {
           decorator.applyDecoration()
       }
   }

2. 合理利用现有Android实现：

   • 复用RecyclerView.Adapter

   • 利用ContextWrapper扩展功能

   • 使用系统提供的Proxy模式实现

3. 性能优化注意事项：

   • 避免装饰器模式多层嵌套

   • 享元模式注意线程安全

   • 适配器模式优化ViewHolder

4. 测试友好设计：

   // 使用接口便于测试
   interface ImageLoader {
       void load(String url, ImageView target);
   }
   
   // 真实实现
   class GlideImageLoader implements ImageLoader { /*...*/ }
   
   // 测试桩
   class MockImageLoader implements ImageLoader { /*...*/ }

   五、总结与思考

   结构型设计模式为Android开发提供了强大的架构工具。通过合理应用这些模式，我们可以：

5. 构建更灵活的UI组件体系

6. 实现高效的资源管理

7. 创建可维护的业务逻辑层

8. 设计松耦合的系统架构