一、从煮面条理解视图绘制

很多人在刚接触自定义视图时,会被 draw(_:)、setNeedsDisplay、Core Graphics 这些词吓到。其实你可以把屏幕上的一个视图想象成一口锅,把绘制内容想象成煮面条。系统说“锅热了,可以煮面了”,你的代码才开始往锅里放面条。如果你在锅还没热的时候就倒水,那就白费力气。理解了这个节奏,后面所有知识点都能串起来。

自定义视图的核心,就是让你自己决定这口锅里放什么食材。系统自带的 UILabel、UIImageView 帮我们做好了固定口味的菜,但当你需要画一条虚线、一个带圆环的进度条、或者一个带阴影的统计卡片时,直接改 frame 和颜色已经不够用了,这时候就需要自己掌握锅铲。

1.1 什么是自定义视图

自定义视图就是继承 UIView 或者它的子类,然后重写它的绘制方法。最简单的写法是这样:

// 技术栈: Swift + UIKit
import UIKit

/// 一个什么都不画的自定义视图
final class MyEmptyView: UIView {
    /// 重写 draw 方法,系统在需要绘制时调用
    override func draw(_ rect: CGRect) {
        // 这里可以画东西,暂时留空
    }
}

你可能会问:“我什么都没画,为什么还要重写 draw?” 因为一旦重写了 draw(_:),系统就知道这个视图需要走“自己画”的流程。如果不重写,系统会认为视图只有背景色,不需要额外的绘制工作。

1.2 绘制到底发生在什么时候

绘制不是你想画就立刻画的。你调一个方法告诉系统“我的视图脏了,该重画了”,系统不一定会马上执行绘制,而是等本轮 run loop 结束,或者等下一次刷新周期再统一处理。这就像你叫了外卖,不是刚下单厨师就立刻端菜出来,而是等所有订单汇总后一起做。

常用的触发方式有:

  • 第一次把视图加到窗口上
  • 修改了视图的 frame 且布局发生了变化
  • 手动调用 setNeedsDisplay()
  • 设置一些会影响绘制的属性,比如 backgroundColor 变了

系统在决定要绘制时,会调用 draw(_:),把需要重画的区域传给你。你只需要在这个方法里用 Core Graphics 把内容画出来。

二、绘制原理的底层故事

draw(_:) 看起来只是一个小方法,背后却牵动着一整套渲染流程。

2.1 setNeedsDisplay 的作用

setNeedsDisplay() 是给视图打一个“脏标记”,它并不立即执行 draw(_:)。真正的绘制要等到下一个刷新时机。iOS 的屏幕刷新通常是 60 次每秒,也就是每 16.7 毫秒一帧。你在这个周期内多次调用 setNeedsDisplay(),系统也只会在这一个周期结束时画一次。

所以,高频更新 UI 时不要每帧都调 setNeedsDisplay(),那样反而会造成浪费。正确做法是:数据变了,标记一下;时机到了,统一画一次。

2.2 draw(_:) 里的画笔

系统为你的视图准备了一块画布,这块画布其实是一个位图上下文。你可以用 Core Graphics 的 API 在上面画线、填充颜色、绘制文字。每次 draw(_:) 被调用,画布会被清空,然后重新画一遍。你可以把它想象成一张草稿纸,每次画新东西之前都要先擦掉旧痕迹。

来看一个简单但完整的例子,画一个圆角背景和一行文字:

// 技术栈: Swift + UIKit
import UIKit

/// 自绘一个带背景色和文字的视图
final class MySampleView: UIView {

    /// 外部传入要显示的文字
    var title: String = "绘制示例" {
        didSet {
            // 文字变了,标记需要重绘
            setNeedsDisplay()
        }
    }

    /// 系统绘制入口
    override func draw(_ rect: CGRect) {
        // 1. 获取当前上下文
        guard let ctx = UIGraphicsGetCurrentContext() else { return }

        // 2. 绘制圆角矩形背景
        let path = UIBezierPath(roundedRect: bounds, cornerRadius: 12)
        ctx.addPath(path.cgPath)
        ctx.setFillColor(UIColor.systemBlue.cgColor)
        ctx.fillPath()

        // 3. 绘制文字
        let attributes: [NSAttributedString.Key: Any] = [
            .font: UIFont.boldSystemFont(ofSize: 20),
            .foregroundColor: UIColor.white
        ]
        let size = title.size(withAttributes: attributes)
        let point = CGPoint(x: (bounds.width - size.width) / 2,
                            y: (bounds.height - size.height) / 2)
        title.draw(at: point, withAttributes: attributes)
    }
}

这里最重要的是 UIGraphicsGetCurrentContext(),它拿到的是当前绘制环境的上下文。后面所有的画线、填充、裁剪都基于这个上下文。

2.3 系统怎么把内容送到屏幕上

draw(_:) 画完之后,内容会先存在一个内存位图里。接着,这个位图会被提交给渲染服务,最终由 GPU 合成到屏幕上。这里牵扯到两个概念:CPU 绘制和 GPU 合成。

draw(_:) 里的代码是由 CPU 执行的。CPU 把图形一个个画到位图里,这个过程叫光栅化。光栅化后的位图再传给 GPU,GPU 负责把多个图层拼成最终画面。如果一帧里 CPU 绘制太重,GPU 等不到数据,画面就会卡顿。

所以,高性能渲染的核心,就是想办法减少 CPU 绘制的时间,减少 GPU 合成的负担。

三、完整示例:做一个统计卡片视图

光讲原理容易忘,我们来写一个实际能用的自定义视图:一个统计卡片,左边显示数字,右边显示描述,底部加一条进度条。这个例子覆盖了绘制文字、画线、画圆角矩形等常见需求。

// 技术栈: Swift + UIKit
import UIKit

/// 统计卡片视图
final class StatisticsCardView: UIView {

    /// 进度值,范围 0~1
    var progress: CGFloat = 0.6 {
        didSet { setNeedsDisplay() }
    }

    /// 数字
    var valueText: String = "86%" {
        didSet { setNeedsDisplay() }
    }

    /// 描述文字
    var subtitle: String = "本月目标完成率" {
        didSet { setNeedsDisplay() }
    }

    /// 绘制入口
    override func draw(_ rect: CGRect) {
        guard let ctx = UIGraphicsGetCurrentContext() else { return }

        // 1. 背景:白色圆角矩形
        let cardRect = bounds.insetBy(dx: 0, dy: 0)
        let cardPath = UIBezierPath(roundedRect: cardRect, cornerRadius: 16)
        ctx.addPath(cardPath.cgPath)
        ctx.setFillColor(UIColor.systemBackground.cgColor)
        ctx.fillPath()

        // 2. 顶部数字,使用大号字体
        let valueAttributes: [NSAttributedString.Key: Any] = [
            .font: UIFont.monospacedDigitSystemFont(ofSize: 34, weight: .bold),
            .foregroundColor: UIColor.label
        ]
        let valueSize = valueText.size(withAttributes: valueAttributes)
        valueText.draw(at: CGPoint(x: 16, y: 16), withAttributes: valueAttributes)

        // 3. 描述文字,放在数字下方
        let subAttributes: [NSAttributedString.Key: Any] = [
            .font: UIFont.systemFont(ofSize: 14),
            .foregroundColor: UIColor.secondaryLabel
        ]
        subtitle.draw(at: CGPoint(x: 16, y: 16 + valueSize.height + 8),
                      withAttributes: subAttributes)

        // 4. 进度条背景
        let barY = bounds.height - 12 - 8
        let barWidth = bounds.width - 32
        let backgroundBar = CGRect(x: 16, y: barY, width: barWidth, height: 12)
        let bgPath = UIBezierPath(roundedRect: backgroundBar, cornerRadius: 6)
        ctx.addPath(bgPath.cgPath)
        ctx.setFillColor(UIColor.systemGray5.cgColor)
        ctx.fillPath()

        // 5. 进度条前景
        let progressWidth = barWidth * max(0, min(progress, 1))
        let foregroundBar = CGRect(x: 16, y: barY,
                                   width: progressWidth, height: 12)
        let fgPath = UIBezierPath(roundedRect: foregroundBar, cornerRadius: 6)
        ctx.addPath(fgPath.cgPath)
        ctx.setFillColor(UIColor.systemGreen.cgColor)
        ctx.fillPath()

        // 6. 绘制一条分隔线,增加细节
        let line = UIBezierPath()
        line.move(to: CGPoint(x: 16, y: 70))
        line.addLine(to: CGPoint(x: bounds.width - 16, y: 70))
        line.lineWidth = 1
        ctx.addPath(line.cgPath)
        ctx.setStrokeColor(UIColor.separator.cgColor)
        ctx.strokePath()
    }
}

这个视图的用法和普通视图一样,直接添加到界面上即可。每次修改 progress 或 valueText,都会触发 setNeedsDisplay(),然后系统在下一帧重绘。

四、高性能渲染的实现方法

画一个简单的视图不难,难的是在复杂界面里保持流畅。下面这些方法能帮你把绘制性能提上去。

4.1 少画一点,再少画一点

draw(_:) 里的代码越少,CPU 压力越小。你可以把不必要绘制的内容去掉,比如本来可以用 backgroundColor 实现的纯色背景,就不要在 draw 里用 Core Graphics 去填一个矩形。又比如圆角,可以直接设置 layer.cornerRadius 和 layer.masksToBounds,没有必要自己画路径。

另外,注意 rect 参数。draw(_:) 的 rect 是“需要重绘的区域”,如果你的内容没有变化,可以早一点 return。举个例子:

// 技术栈: Swift + UIKit
override func draw(_ rect: CGRect) {
    // 如果进度没有变化,就不重画进度条区域
    guard progressDidChange else { return }
    // 只重绘 rect 区域
    drawProgressBar(rect)
}

4.2 巧用 CALayer 和 shouldRasterize

UIView 本身就封装了一个 CALayer。很多绘制能力,CALayer 自己就具备了。比如渐变、阴影、边框、圆角,你设置对应属性后,由 Core Animation 在合成阶段处理,不占用 CPU 绘制时间。但有些属性用多了会导致“离屏渲染”,这是性能杀手之一。

shouldRasterize 可以把一个复杂的图层结构提前光栅化成位图,下次绘制时直接复用位图。如果图层内容不经常变,开启它会有明显提升;但要是图层内容频繁变动,光栅化缓存会不断失效,反而更慢。

一个典型场景是列表里的卡片视图,卡片内容保持不变,可以这样设置:

// 技术栈: Swift + UIKit
cardView.layer.shouldRasterize = true
cardView.layer.rasterizationScale = UIScreen.main.scale

4.3 异步绘制

draw(_:) 在主线程执行,如果绘制太复杂,会卡住用户交互。我们可以把绘制放到后台线程,画完之后再把结果送回主线程显示。UIKit 的 draw 本身不是线程安全的,但 Core Graphics 支持后台创建位图上下文。常见做法是用 UIGraphicsImageRenderer 在子线程生成图片,然后回到主线程设置到 UIImageView 上。

下面是一个简单的异步绘制示例:

// 技术栈: Swift + UIKit
import UIKit

final class AsyncCardView: UIView {
    private let imageView = UIImageView(frame: .zero)

    override init(frame: CGRect) {
        super.init(frame: frame)
        addSubview(imageView)
        imageView.frame = bounds
        imageView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
    }

    required init?(coder: NSCoder) {
        fatalError("not implemented")
    }

    func renderCardAsync() {
        let size = bounds.size
        DispatchQueue.global(qos: .userInitiated).async {
            // 在子线程绘制
            let renderer = UIGraphicsImageRenderer(size: size)
            let image = renderer.image { ctx in
                // 画背景
                UIColor.systemGray6.setFill()
                UIBezierPath(roundedRect: CGRect(origin: .zero, size: size),
                             cornerRadius: 12).fill()
                // 画文字
                let attrs: [NSAttributedString.Key: Any] = [
                    .font: UIFont.systemFont(ofSize: 18),
                    .foregroundColor: UIColor.label
                ]
                ("异步绘制结果").draw(at: CGPoint(x: 20, y: 20), withAttributes: attrs)
            }
            // 回主线程显示
            DispatchQueue.main.async {
                self.imageView.image = image
            }
        }
    }
}

这个方案的核心思想是:主线程不碰任何绘图 API,只负责简单布局;复杂绘制全部交给后台线程。

4.4 避免离屏渲染

当图层需要先被渲染到一个临时缓冲区,再合成到主屏幕时,就发生了离屏渲染。常见的触发条件有设置 cornerRadius 且 masksToBounds = true、设置圆角的同时又有阴影、使用 mask 等。离屏渲染需要额外切换上下文,GPU 工作量上升,性能自然下降。

尽量避免同时使用圆角和阴影。如果必须保留圆角,可以自己画圆角图片,或者只给最外层的容器加阴影。还可以用 shadowPath 代替默认阴影计算:

// 技术栈: Swift + UIKit
cardView.layer.shadowPath = UIBezierPath(roundedRect: cardView.bounds,
                                         cornerRadius: 12).cgPath

五、应用场景、优缺点

5.1 应用场景

自定义视图适合以下场景:

  • 图表:折线图、柱状图、饼图
  • 复杂控件:带进度环的按钮、评分星星、签名板
  • 高性能列表项:需要频繁刷新数值的行情卡片
  • 特殊形状:气泡、不规则裁剪

这些用系统控件拼起来会非常麻烦,自己画反而简单高效。

5.2 技术优缺点

优点:

  • 灵活,想画什么就画什么
  • 没有系统控件的固定样式限制
  • 可以针对特定区域做精确刷新

缺点:

  • 学习成本高,需要懂 Core Graphics
  • 绘制代码比较底层,不好维护
  • 如果写得不好,性能容易翻车

六、注意事项

  1. 不要在 draw(_:) 里创建大量临时对象,否则每帧都会触发内存分配。
  2. 频繁修改 frame 会引发重绘,尽量在布局完成后一次性设置。
  3. setNeedsDisplay() 不要调太多次,系统只会合并到同一帧里处理。
  4. 如果视图内容不变,尽量避免重绘,必要时把绘制结果缓存成图片。
  5. 真机测试性能,模拟器不能准确反映 GPU 压力。
  6. 多关注 Instruments 的 Core Animation 工具,它能直接看到离屏渲染的黄色标志。

七、文章总结

自定义视图的绘制原理并不神秘,核心就是“系统说画就画”的机制。你通过 setNeedsDisplay() 告诉系统内容变了,系统在合适的时机调用 draw(_:),你在这个方法里画东西。高性能渲染的关键在于减少无意义的重绘、降低 CPU 绘制成本、避免离屏渲染,必要时使用异步绘制。

在实际开发中,不要一上来就重写 draw(_:),先想想系统控件和 CALayer 能不能满足需求。只有真正需要自由绘制时,才打开这扇门。掌握好这些方法,你就能在流畅度和灵活性之间找到最佳平衡点,让自己的 App 既有好看的效果,又能稳定运行。