使用Riverpod（Flutter）维护树形结构遇到的问题

算力阿峰

2026-7-12

问题根源与修复方案

核心问题分析

你的代码存在两个关键问题，导致树形结构状态丢失：

状态仅维护当前节点，未保留整个树的引用：原CurrentNodeNotifier的状态只存储单个Node，当切换到子节点后，根节点的最新状态没有被Notifier持有。添加子节点时创建的新根节点，与之前子节点的parentNode指向的旧根节点是两个不同对象，返回父节点时拿到的是旧根，自然丢失后续添加的子节点。
Node类的不可变性被破坏：childNodes虽然是final，但默认是可变列表，直接调用addNode修改列表内容，不符合Riverpod依赖的不可变状态设计，会导致状态更新不被正确跟踪。

具体修复步骤

1. 重构状态类，维护全局树形结构

定义包含根节点和当前节点的状态类，确保整个树的结构始终被Notifier持有：

class FileSystemState {
  final Node root;
  final Node currentNode;

  FileSystemState({required this.root, required this.currentNode});

  FileSystemState copyWith({Node? root, Node? currentNode}) {
    return FileSystemState(
      root: root ?? this.root,
      currentNode: currentNode ?? this.currentNode,
    );
  }
}

2. 改造Node类，确保完全不可变

将childNodes改为不可变列表，移除直接修改列表的addNode方法，所有修改通过copyWith创建新节点：

class Node {
  final Node? parentNode;
  final String id;
  final String value;
  final List<Node> childNodes;

  Node({
    this.parentNode,
    required this.id,
    required this.value,
    List<Node> childNodes = const [],
  }) : childNodes = List.unmodifiable(childNodes); // 强制不可变列表

  Node copyWith({
    Node? parentNode,
    String? id,
    String? value,
    List<Node>? childNodes,
  }) {
    return Node(
      parentNode: parentNode ?? this.parentNode,
      id: id ?? this.id,
      value: value ?? this.value,
      childNodes: childNodes != null ? List.unmodifiable(childNodes) : this.childNodes,
    );
  }
}

3. 重写Notifier，正确维护树形状态

修改Notifier以FileSystemState为状态，实现递归更新和查找节点的方法，确保所有操作都基于根节点更新：

class FileSystemNotifier extends StateNotifier<FileSystemState> {
  FileSystemNotifier()
      : super(
          FileSystemState(
            root: Node(
              parentNode: null,
              id: uuid.v4(),
              value: 'ROOT',
            ),
            currentNode: Node(
              parentNode: null,
              id: uuid.v4(),
              value: 'ROOT',
            ),
          ),
        );

  // 递归查找节点
  Node _findNode(Node node, String targetId) {
    if (node.id == targetId) return node;
    for (final child in node.childNodes) {
      final found = _findNode(child, targetId);
      if (found.id == targetId) return found;
    }
    throw Exception('节点未找到');
  }

  // 递归更新节点树
  Node _updateNode(Node currentRoot, Node targetNode, Node updatedNode) {
    if (currentRoot.id == targetNode.id) {
      return updatedNode;
    }
    return currentRoot.copyWith(
      childNodes: currentRoot.childNodes.map((child) {
        return _updateNode(child, targetNode, updatedNode);
      }).toList(),
    );
  }

  // 添加子节点
  void addNode(String value) {
    final newNode = Node(
      parentNode: state.currentNode,
      id: uuid.v4(),
      value: value,
    );
    // 创建当前节点的副本，添加新子节点
    final updatedCurrentNode = state.currentNode.copyWith(
      childNodes: [...state.currentNode.childNodes, newNode],
    );
    // 更新根节点
    final newRoot = _updateNode(state.root, state.currentNode, updatedCurrentNode);
    // 从新根中找到当前节点的最新引用
    final newCurrentNode = _findNode(newRoot, updatedCurrentNode.id);
    // 更新状态
    state = state.copyWith(root: newRoot, currentNode: newCurrentNode);
  }

  // 切换当前节点
  void changeCurrentNode(Node newNode) {
    final targetNode = _findNode(state.root, newNode.id);
    state = state.copyWith(currentNode: targetNode);
  }

  // 返回父节点
  void returnToParent() {
    if (state.currentNode.parentNode != null) {
      final parentNode = _findNode(state.root, state.currentNode.parentNode!.id);
      state = state.copyWith(currentNode: parentNode);
    }
  }
}

final fileSystemProvider = StateNotifierProvider<FileSystemNotifier, FileSystemState>((ref) {
  return FileSystemNotifier();
});

修复原理说明

通过FileSystemState持有根节点，确保整个树形结构的状态始终被全局跟踪，不会因切换当前节点而丢失。
所有节点操作都基于不可变对象，通过copyWith创建新节点，保证Riverpod能正确检测状态变化并更新UI。
递归更新和查找方法确保修改节点时，整个树的引用链都是最新的，避免出现新旧对象引用不一致的问题。

内容的提问来源于stack exchange，提问作者CHBC