# Flutter Custom Render Objects 2026: Custom Painting và Câu Hỏi Phỏng Vấn

> Làm chủ pipeline rendering của Flutter với custom RenderObjects, tìm hiểu khi nào nên chọn CustomPainter vs RenderBox, và chuẩn bị cho các câu hỏi phỏng vấn level senior về vòng đời Element-RenderObject.

- Published: 2026-09-11
- Updated: 2026-09-11
- Author: Anthony Fillion-Maillet
- Tags: flutter, rendering, custom-painter, render-object, dart, mobile, interview
- Reading time: 10 min

---

Flutter custom RenderObjects cung cấp quyền truy cập cấp thấp nhất vào pipeline rendering của framework, cho phép kiểm soát pixel-perfect đối với layout, painting và hit testing mà các widget tiêu chuẩn không thể cung cấp. Hiểu được layer này phân biệt ứng viên xây dựng ứng dụng Flutter với những người xây dựng chính Flutter.

> **Tín hiệu phỏng vấn**
>
> Các vị trí Flutter senior kỳ vọng ứng viên giải thích ba tree (Widget, Element, RenderObject), trình bày khi nào custom RenderObject vượt trội hơn CustomPainter, và demo một implementation hoạt động xử lý đúng constraints và hit testing.

## Kiến trúc three-tree điều khiển rendering Flutter

Flutter render các frame thông qua ba tree kết nối với nhau, mỗi tree có trách nhiệm riêng biệt. Widget tree chứa các đối tượng cấu hình immutable mà developer viết. Element tree hoạt động như cầu nối persistent tồn tại qua các rebuild và quản lý lifecycle. RenderObject tree thực hiện computation thực tế: layout, painting và hit testing.

Sự phân biệt này quan trọng cho performance. Khi `setState` trigger rebuild, Flutter duyệt Element tree và diff Widget tree mới với tree cũ. Chỉ những Element thay đổi mới tạo RenderObject mới hoặc cập nhật những cái đang có. Cơ chế reconciliation này giải thích tại sao Flutter có thể rebuild widget 60 lần mỗi giây mà không bị drop frame.

```dart
// custom_gauge_widget.dart
// A minimal widget-element-renderobject structure
class GaugeWidget extends LeafRenderObjectWidget {
  const GaugeWidget({super.key, required this.value});
  
  final double value; // 0.0 to 1.0
  
  @override
  RenderObject createRenderObject(BuildContext context) {
    return RenderGauge(value: value);
  }
  
  @override
  void updateRenderObject(BuildContext context, RenderGauge renderObject) {
    renderObject.value = value; // Update without recreating
  }
}
```

Base class `LeafRenderObjectWidget` chỉ ra rằng widget này không có children. Khi value thay đổi, `updateRenderObject` mutate instance RenderGauge hiện có thay vì thay thế nó, giữ lại các computation layout đã được cache.

## RenderBox vs RenderObject: chọn base class phù hợp

Hầu hết các scenario custom rendering nên extend `RenderBox`, không phải `RenderObject` trực tiếp. RenderBox implement mô hình Cartesian box với constraints width và height, phù hợp với 99% use case trong ứng dụng mobile và web. [Documentation của RenderObject class](https://api.flutter.dev/flutter/rendering/RenderObject-class.html) khuyến nghị subclass RenderObject trực tiếp chỉ khi xây dựng một protocol layout khác biệt về cơ bản, như hệ tọa độ polar.

| Base Class | Khi Nào Sử Dụng | Ví Dụ |
|------------|-----------------|-------|
| RenderBox | Layout 2D tiêu chuẩn với box constraints | Custom chart, gauge, drawing surface |
| RenderSliver | Nội dung scrollable với lazy loading dựa trên viewport | Custom list header, hiệu ứng parallax |
| RenderObject | Hệ tọa độ non-Cartesian | Menu radial, polar chart |

Câu hỏi phỏng vấn "khi nào bạn sẽ subclass RenderObject trực tiếp?" kiểm tra liệu ứng viên có hiểu rằng RenderBox không phải là lựa chọn duy nhất nhưng là lựa chọn đúng cho hầu hết các vấn đề.

## Implement custom RenderBox: ví dụ gauge

Một widget gauge thực tế demo ba method mà mọi custom RenderBox phải xử lý: `performLayout`, `paint` và hit testing. Gauge nhận value từ 0.0 đến 1.0 và vẽ một arc đại diện cho percentage đó.

```dart
// render_gauge.dart
class RenderGauge extends RenderBox {
  RenderGauge({required double value}) : _value = value;
  
  double _value;
  double get value => _value;
  set value(double newValue) {
    if (_value == newValue) return;
    _value = newValue;
    markNeedsPaint(); // Repaint only, layout unchanged
  }
  
  @override
  void performLayout() {
    // Accept whatever size the parent offers, or use a default
    size = constraints.constrain(const Size(200, 200));
  }
  
  @override
  void paint(PaintingContext context, Offset offset) {
    final canvas = context.canvas;
    final rect = offset & size;
    final center = rect.center;
    final radius = size.shortestSide / 2 - 10;
    
    // Background arc (gray)
    final backgroundPaint = Paint()
      ..color = const Color(0xFFE0E0E0)
      ..style = PaintingStyle.stroke
      ..strokeWidth = 8
      ..strokeCap = StrokeCap.round;
    
    canvas.drawArc(
      Rect.fromCircle(center: center, radius: radius),
      2.4, // Start angle (roughly 7 o'clock)
      4.9, // Sweep angle (to 5 o'clock)
      false,
      backgroundPaint,
    );
    
    // Foreground arc (colored, proportional to value)
    final foregroundPaint = Paint()
      ..color = const Color(0xFF2196F3)
      ..style = PaintingStyle.stroke
      ..strokeWidth = 8
      ..strokeCap = StrokeCap.round;
    
    canvas.drawArc(
      Rect.fromCircle(center: center, radius: radius),
      2.4,
      4.9 * _value, // Sweep proportional to value
      false,
      foregroundPaint,
    );
  }
  
  @override
  bool hitTestSelf(Offset position) => true; // Accept taps anywhere in bounds
}
```

Việc gọi `markNeedsPaint` khi value thay đổi là có chủ đích. Gọi `markNeedsLayout` sẽ lãng phí vì kích thước gauge không phụ thuộc vào value. Sự phân biệt này là câu hỏi phỏng vấn phổ biến: "Khi nào bạn gọi markNeedsLayout so với markNeedsPaint?"

## CustomPainter vs custom RenderObject: framework quyết định

CustomPainter wrap một canvas và delegate painting cho một class riêng. Custom RenderObject kiểm soát layout, painting và hit testing như một đơn vị. Trade-off là độ phức tạp so với kiểm soát.

CustomPainter phù hợp khi:
- Layout đã được xử lý bởi widget parent (thường là SizedBox hoặc Container)
- Không cần custom hit testing, hoặc toàn bộ vùng painted có thể tap
- Logic painting là stateless hoặc driven bởi single value

Custom RenderObject phù hợp khi:
- Layout phụ thuộc vào các calculation nội bộ (intrinsic sizing, baseline alignment)
- Hit testing phải chính xác đến các shape được paint, không phải bounding box
- Performance yêu cầu bỏ qua các pass layout không cần thiết
- Widget cần tham gia vào animation ở render level

```dart
// custom_painter_approach.dart
// Simpler, but layout and hit testing are external
class GaugePainter extends CustomPainter {
  final double value;
  GaugePainter(this.value);
  
  @override
  void paint(Canvas canvas, Size size) {
    // Same arc-drawing logic
  }
  
  @override
  bool shouldRepaint(GaugePainter old) => old.value != value;
}

// Usage requires explicit sizing
SizedBox(
  width: 200,
  height: 200,
  child: CustomPaint(
    painter: GaugePainter(0.75),
  ),
)
```

Cách tiếp cận CustomPainter tạo ra nhiều widget hơn (SizedBox, CustomPaint) và đẩy trách nhiệm layout cho caller. Đối với một component gauge có thể tái sử dụng, phiên bản RenderBox đóng gói behavior tốt hơn.

## Truyền constraints và kích thước intrinsic

Constraints chảy xuống render tree từ parent đến child. Size chảy lên từ child đến parent. Protocol hai chiều này là xương sống của thuật toán layout và là chủ đề phỏng vấn thường gặp.

RenderBox nhận `BoxConstraints` chứa minimum và maximum width và height. Method `performLayout` phải đặt `size` thành một giá trị trong constraints đó. Vi phạm constraints tạo ra assertion debug trong development và behavior không xác định trong production.

```dart
// render_gauge.dart (extended)
class RenderGauge extends RenderBox {
  // ... previous code ...
  
  @override
  double computeMinIntrinsicWidth(double height) => 100;
  
  @override
  double computeMaxIntrinsicWidth(double height) => 300;
  
  @override
  double computeMinIntrinsicHeight(double width) => 100;
  
  @override
  double computeMaxIntrinsicHeight(double width) => 300;
}
```

Kích thước intrinsic trả lời câu hỏi: "Render object này muốn lớn bao nhiêu, bỏ qua constraints?" Các widget như `IntrinsicWidth` và `IntrinsicHeight` query các method này để xác định kích thước children của chúng. Implement đúng cho phép gauge tham gia vào layout linh hoạt mà không cần sizing tường minh.

## Hit testing với độ chính xác

Hit testing mặc định cho RenderBox kiểm tra liệu vị trí tap có nằm trong bounding rectangle hay không. Đối với gauge với shape arc, hit testing chính xác yêu cầu override `hitTest` hoặc `hitTestSelf`.

```dart
// render_gauge.dart (hit testing)
@override
bool hitTestSelf(Offset position) {
  final center = size.center(Offset.zero);
  final radius = size.shortestSide / 2 - 10;
  final distanceFromCenter = (position - center).distance;
  
  // Only register hits on the arc stroke, not the center
  return distanceFromCenter >= radius - 10 && distanceFromCenter <= radius + 10;
}
```

Implementation này từ chối tap ở giữa gauge, chỉ chấp nhận những tap gần arc. Câu hỏi tiếp theo trong phỏng vấn: "Làm thế nào để bạn làm cho gauge này draggable để thay đổi value?" Trả lời: implement `handleEvent` và chuyển đổi vị trí tap thành góc, sau đó thành value.

## Lifecycle Element và attachment RenderObject

Elements tạo và sở hữu RenderObjects. Các method lifecycle `mount`, `update` và `unmount` trên Element tương ứng với `attach`, render object tồn tại, và `detach` ở phía RenderObject. Hiểu lifecycle này giải thích memory management và resource cleanup.

Khi một Element mount, nó gọi `createRenderObject` trên Widget của nó. RenderObject được trả về được attach vào render tree thông qua `attach`, kết nối nó với `PipelineOwner` để schedule layout và paint. Khi Element unmount, `detach` ngắt kết nối RenderObject, và `dispose` giải phóng resource.

```dart
// render_gauge.dart (resource cleanup)
class RenderGauge extends RenderBox {
  // ... previous code ...
  
  ui.Image? _cachedBackground;
  
  @override
  void dispose() {
    _cachedBackground?.dispose(); // Release GPU resources
    _cachedBackground = null;
    super.dispose();
  }
}
```

Không dispose GPU resource (Image, Picture, Layer) gây ra memory leak tích lũy khi widget vào và ra khỏi tree. Đây là concern cấp production phân biệt implementation được polish với tutorial.

## Performance: khi custom RenderObjects vượt trội hơn widget composition

Mô hình widget composition của Flutter xử lý hầu hết các pattern UI một cách hiệu quả. Custom RenderObjects mang lại lợi ích trong các scenario cụ thể:

1. **Tránh overhead rebuild**: RenderObject update qua `markNeedsPaint` bỏ qua hoàn toàn build phase, trong khi cách tiếp cận dựa trên widget phải rebuild và diff.

2. **Batch painting**: một RenderObject duy nhất paint nhiều element (chart với 10,000 data point) vượt trội hơn 10,000 widget mỗi cái với RenderObject riêng.

3. **Protocol layout custom**: layout vi phạm mô hình constraint single-pass (thương lượng two-pass, element chồng chéo) yêu cầu kiểm soát cấp RenderObject.

> **Tối ưu hóa sớm**
>
> Hầu hết ứng dụng không cần custom RenderObjects. Profile với DevTools trước khi đi xuống layer render. Widget tree có cấu trúc tốt với const constructor thường vượt trội hơn custom renderer được implement kém.

## Câu hỏi phỏng vấn về internal rendering Flutter

Phỏng vấn cấp senior và staff thăm dò pipeline rendering vì nó tiết lộ chiều sâu hiểu biết framework. Các câu hỏi phổ biến và câu trả lời kỳ vọng:

**Q: Giải thích ba tree trong Flutter.**
A: Widget (config immutable), Element (handle persistent, quản lý lifecycle), RenderObject (layout, paint, hit test). Elements tồn tại qua rebuild và diff widget để giảm thiểu mutation RenderObject.

**Q: Khi nào bạn sẽ chọn custom RenderObject thay vì CustomPainter?**
A: Khi cần custom intrinsic sizing, hit testing chính xác ngoài bounding box, hoặc tham gia trực tiếp vào protocol layout. CustomPainter delegate layout cho ancestor.

**Q: markNeedsLayout làm gì khác với markNeedsPaint?**
A: markNeedsLayout schedule một pass layout (constraints, sizing) sau đó paint. markNeedsPaint chỉ schedule paint, bỏ qua layout. Sử dụng option tối thiểu để tránh computation lãng phí.

**Q: Constraints chảy như thế nào trong layout Flutter?**
A: Xuống từ parent đến child (constraints vào), lên từ child đến parent (size ra). Single-pass, traversal O(n). Parents có thể thắt chặt constraints; children phải tuân thủ.

**Q: Điều gì xảy ra nếu RenderObject vi phạm constraints của nó?**
A: Mode debug throw assertion. Mode release tạo behavior không xác định, thường là clipping hoặc overflow không có warning.

Thực hành trình bày các câu trả lời này một cách ngắn gọn. Interviewer đánh giá cao sự rõ ràng hơn sự đầy đủ.

## Áp dụng custom rendering vào các scenario phỏng vấn thực tế

Kiến thức về layer rendering của Flutter áp dụng trực tiếp cho [chuẩn bị phỏng vấn Flutter](/technologies/flutter). Ứng viên có thể vẽ subclass RenderBox trên whiteboard, giải thích protocol constraint, và thảo luận khi nào nên đi xuống dưới layer widget thể hiện chiều sâu mà các vị trí senior yêu cầu.

Những điểm chính:

- Mô hình three-tree (Widget, Element, RenderObject) cho phép diff hiệu quả và cập nhật GPU tối thiểu
- RenderBox xử lý layout Cartesian; subclass RenderObject trực tiếp chỉ cho hệ tọa độ thay thế
- CustomPainter phù hợp cho các task chỉ painting; custom RenderObjects đóng gói layout, painting và hit testing
- Kích thước intrinsic cho phép composition linh hoạt với các widget sizing như IntrinsicWidth
- dispose() phải giải phóng GPU resource để ngăn memory leak
- markNeedsPaint rẻ hơn markNeedsLayout; sử dụng option tối thiểu
- Profile trước khi tối ưu; widget composition đã hiệu quả cho hầu hết use case

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/vi/blog/flutter/flutter-custom-render-objects-custom-painting-2026