鸿蒙ArkUI瀑布流开发实战：WaterFlow组件与LazyForEach高效实现

瀑布流布局（Waterfall Flow）是购物、资讯类应用的核心交互设计，如何在鸿蒙ArkUI中高效实现多列动态加载与滚动优化？本文将以小红书类似的结构为例，手把手教你使用WaterFlow组件与懒加载技术，解决数据量大时的性能瓶颈，并提供多设备适配方案。

Tw777

1822人浏览 · 2025-03-11 10:30:00

Tw777 · 2025-03-11 10:30:00 发布

前言

瀑布流布局（Waterfall Flow）是购物、资讯类应用的核心交互设计，如何在鸿蒙ArkUI中高效实现多列动态加载与滚动优化？本文将以小红书类似的结构为例，手把手教你使用WaterFlow组件与LazyForEach懒加载技术，解决数据量大时的性能瓶颈，并提供多设备适配方案。

一、ArkUI瀑布流核心组件

1. WaterFlow组件

鸿蒙的WaterFlow组件是瀑布流布局的容器，支持以下关键属性：

WaterFlow({  
  columnsTemplate: '1fr 1fr',  // 列数（示例为2列）
  columnsGap: 8,              // 列间距  
  rowsGap: 16,                // 行间距  
  layoutDirection: FlowDirection.Vertical // 排列方向  
})

2. LazyForEach懒加载

通过LazyForEach动态渲染数据，避免一次性加载全部内容：

LazyForEach(this.productData, (item: Product) => {  
  FlowItem() {  
    // 商品卡片组件  
    ProductItem({ item })  
  }  
}, (item: Product) => item.id.toString())

效果图：

实现思路

我们将通过以下步骤来实现瀑布流布局：

数据准备：创建一个数据源类，用于管理和提供瀑布流所需的数据。
随机尺寸计算：为每个元素生成随机的宽度和高度，同时控制高度范围，实现视觉上的错落感。
布局构建：使用 WaterFlow 组件和 LazyForEach 动态渲染数据，实现瀑布流布局。
数据加载优化：在滚动过程中，当即将触底时，动态加载更多数据，提高用户体验。

1.数据源类 `WaterFlowDataSource.ets`

// WaterFlowDataSource.ets

// 实现IDataSource接口的对象，用于瀑布流组件加载数据
export class WaterFlowDataSource implements IDataSource {
  private dataArray: number[] = [];
  private listeners: DataChangeListener[] = [];

  constructor() {
    for (let i = 0; i < 100; i++) {
      this.dataArray.push(i);
    }
  }

  // 获取索引对应的数据
  public getData(index: number): number {
    return this.dataArray[index];
  }

  // 通知控制器数据重新加载
  notifyDataReload(): void {
    this.listeners.forEach(listener => {
      listener.onDataReloaded();
    })
  }

  // 通知控制器数据增加
  notifyDataAdd(index: number): void {
    this.listeners.forEach(listener => {
      listener.onDataAdd(index);
    })
  }

  // 通知控制器数据变化
  notifyDataChange(index: number): void {
    this.listeners.forEach(listener => {
      listener.onDataChange(index);
    })
  }

  // 通知控制器数据删除
  notifyDataDelete(index: number): void {
    this.listeners.forEach(listener => {
      listener.onDataDelete(index);
    })
  }

  // 通知控制器数据位置变化
  notifyDataMove(from: number, to: number): void {
    this.listeners.forEach(listener => {
      listener.onDataMove(from, to);
    })
  }

  //通知控制器数据批量修改
  notifyDatasetChange(operations: DataOperation[]): void {
    this.listeners.forEach(listener => {
      listener.onDatasetChange(operations);
    })
  }

  // 获取数据总数
  public totalCount(): number {
    return this.dataArray.length;
  }

  // 注册改变数据的控制器
  registerDataChangeListener(listener: DataChangeListener): void {
    if (this.listeners.indexOf(listener) < 0) {
      this.listeners.push(listener);
    }
  }

  // 注销改变数据的控制器
  unregisterDataChangeListener(listener: DataChangeListener): void {
    const pos = this.listeners.indexOf(listener);
    if (pos >= 0) {
      this.listeners.splice(pos, 1);
    }
  }

  // 增加数据
  public add1stItem(): void {
    this.dataArray.splice(0, 0, this.dataArray.length);
    this.notifyDataAdd(0);
  }

  // 在数据尾部增加一个元素
  public addLastItem(): void {
    this.dataArray.splice(this.dataArray.length, 0, this.dataArray.length);
    this.notifyDataAdd(this.dataArray.length - 1);
  }

  // 在指定索引位置增加一个元素
  public addItem(index: number): void {
    this.dataArray.splice(index, 0, this.dataArray.length);
    this.notifyDataAdd(index);
  }

  // 删除第一个元素
  public delete1stItem(): void {
    this.dataArray.splice(0, 1);
    this.notifyDataDelete(0);
  }

  // 删除第二个元素
  public delete2ndItem(): void {
    this.dataArray.splice(1, 1);
    this.notifyDataDelete(1);
  }

  // 删除最后一个元素
  public deleteLastItem(): void {
    const index = this.dataArray.length - 1; // 先获取原最后一个元素的索引
    this.dataArray.splice(-1, 1);
    this.notifyDataDelete(index); // 传递正确的索引
  }

  // 在指定索引位置删除一个元素
  public deleteItem(index: number): void {
    this.dataArray.splice(index, 1);
    this.notifyDataDelete(index);
  }

  // 重新加载数据
  public reload(): void {
    this.dataArray.splice(1, 1);
    this.dataArray.splice(3, 2);
    this.notifyDataReload();
  }
}

WaterFlowDataSource 类实现了 IDataSource 接口，用于管理瀑布流所需的数据。它提供了数据的增删改查操作，并通过 DataChangeListener 通知数据的变化。

2.Index.ets

核心功能代码：

 @State minSize: number = 130;
  @State maxSize: number = 260;
  @State fontSize: number = 24;
  @State colors: number[] = [0xFFC0CB, 0xDA70D6, 0x6B8E23, 0x6A5ACD, 0x00FFFF, 0x00FF7F];
  scroller: Scroller = new Scroller();
  dataSource: WaterFlowDataSource = new WaterFlowDataSource();
  private itemWidthArray: number[] = [];
  private itemHeightArray: number[] = [];

  // 计算FlowItem宽/高，使用智能随机算法
  getSize(prevHeight: number | null = null) {
    let baseRandom = Math.random();
    let ret:number;
    if (prevHeight === null) {
      // 第一个元素，正常随机生成
      ret = Math.floor(baseRandom * (this.maxSize - this.minSize)) + this.minSize;
    } else {
      // 考虑前一个元素的高度，避免高度差异过大
      let adjustmentRange = Math.min(30, (this.maxSize - this.minSize) / 2);
      let minAdjusted = Math.max(this.minSize, prevHeight - adjustmentRange);
      let maxAdjusted = Math.min(this.maxSize, prevHeight + adjustmentRange);
      ret = Math.floor(baseRandom * (maxAdjusted - minAdjusted)) + minAdjusted;
    }
    return ret;
  }

  // 设置FlowItem的宽/高数组
  setItemSizeArray() {
    let prevHeight: number | null = null;
    for (let i = 0; i < 100; i++) {
      let width = this.getSize();
      let height = this.getSize(prevHeight);
      this.itemWidthArray.push(width);
      this.itemHeightArray.push(height);
      prevHeight = height;
    }
  }

为瀑布流布局中的 FlowItem 元素生成随机的宽度和高度，同时控制高度的范围，以实现视觉上的错落感。

@State minSize 和 @State maxSize：分别表示 FlowItem 元素高度的最小值和最大值，用于控制随机生成的高度范围。
@State fontSize：可能用于设置文本的字体大小，但在这段代码中未直接使用。
@State colors：存储了一组颜色值，用于为 FlowItem 元素设置背景颜色。
scroller：创建了一个 Scroller 对象，可能用于处理滚动相关的操作。
dataSource：创建了一个 WaterFlowDataSource 实例，用于管理瀑布流布局所需的数据。
itemWidthArray 和 itemHeightArray：分别用于存储每个 FlowItem 元素的宽度和高度。

getSize方法：

用于计算 FlowItem 元素的宽度或高度。
参数 prevHeight 表示前一个元素的高度，默认为 null。
如果 prevHeight 为 null，表示是第一个元素，直接在 [minSize, maxSize) 范围内随机生成一个高度。
如果 prevHeight 不为 null，则会考虑前一个元素的高度，避免高度差异过大。具体做法是，计算一个调整范围 adjustmentRange，取 30 和 (maxSize - minSize) / 2 中的较小值。然后根据前一个元素的高度，计算出调整后的最小高度 minAdjusted 和最大高度 maxAdjusted，最后在 [minAdjusted, maxAdjusted) 范围内随机生成一个高度。

setItemSizeArray 方法：

该方法用于为前 100 个 FlowItem 元素设置宽度和高度。
初始化 prevHeight 为 null，表示第一个元素没有前一个元素。
在循环中，调用 getSize 方法分别计算每个元素的宽度和高度，并将其存储到 itemWidthArray 和 itemHeightArray 中。
每次循环结束后，更新 prevHeight 为当前元素的高度，以便下一次循环使用

完整Index.ets代码

// Index.ets
import { WaterFlowDataSource } from './WaterFlowDataSource';

@Entry
@Component
struct Index {
  @State minSize: number = 130;
  @State maxSize: number = 260;
  @State fontSize: number = 24;
  @State colors: number[] = [0xFFC0CB, 0xDA70D6, 0x6B8E23, 0x6A5ACD, 0x00FFFF, 0x00FF7F];
  scroller: Scroller = new Scroller();
  dataSource: WaterFlowDataSource = new WaterFlowDataSource();
  private itemWidthArray: number[] = [];
  private itemHeightArray: number[] = [];

  // 计算FlowItem宽/高，使用智能随机算法
  getSize(prevHeight: number | null = null) {
    let baseRandom = Math.random();
    let ret:number;
    if (prevHeight === null) {
      // 第一个元素，正常随机生成
      ret = Math.floor(baseRandom * (this.maxSize - this.minSize)) + this.minSize;
    } else {
      // 考虑前一个元素的高度，避免高度差异过大
      let adjustmentRange = Math.min(30, (this.maxSize - this.minSize) / 2);
      let minAdjusted = Math.max(this.minSize, prevHeight - adjustmentRange);
      let maxAdjusted = Math.min(this.maxSize, prevHeight + adjustmentRange);
      ret = Math.floor(baseRandom * (maxAdjusted - minAdjusted)) + minAdjusted;
    }
    return ret;
  }

  // 设置FlowItem的宽/高数组
  setItemSizeArray() {
    let prevHeight: number | null = null;
    for (let i = 0; i < 100; i++) {
      let width = this.getSize();
      let height = this.getSize(prevHeight);
      this.itemWidthArray.push(width);
      this.itemHeightArray.push(height);
      prevHeight = height;
    }
  }

  aboutToAppear() {
    this.setItemSizeArray();
  }

  @Builder
  itemFoot() {
    Column() {
      Text(`Footer`)
        .fontSize(10)
        .backgroundColor(Color.Red)
        .width(50)
        .height(50)
        .align(Alignment.Center)
        .margin({ top: 2 })
    }
  }

  build() {
    Column({ space: 2 }) {
      WaterFlow() {
        LazyForEach(this.dataSource, (item: number) => {
          FlowItem() {
            Column() {
              Text("N" + item).fontSize(12).height('16')
              // 存在对应的文件才会显示图片
              Image($r('app.media.phone4'))
                .objectFit(ImageFit.Fill)
                .width('100%')
                .layoutWeight(1)
            }
          }
          .onAppear(() => {
            // 即将触底时提前增加数据
            if (item + 20 == this.dataSource.totalCount()) {
              for (let i = 0; i < 100; i++) {
                this.dataSource.addLastItem();
              }
            }
          })
          .width('100%')
          .height(this.itemHeightArray[item % 100])
          .backgroundColor(this.colors[item % 5])
        }, (item: string) => item)
      }
      .columnsTemplate("1fr 1fr")
      .columnsGap(10)
      .rowsGap(5)
      .backgroundColor(0xFAEEE0)
      .width('100%')
      .height('100%')
      .onReachStart(() => {
        console.info('waterFlow reach start');
      })
      .onScrollStart(() => {
        console.info('waterFlow scroll start');
      })
      .onScrollStop(() => {
        console.info('waterFlow scroll stop');
      })
      .onScrollFrameBegin((offset: number, state: ScrollState) => {
        console.info('waterFlow scrollFrameBegin offset: ' + offset + ' state: ' + state.toString());
        return { offsetRemain: offset };
      })
    }
  }
}

适用HarmonyOS NEXT / API12或以上版本 -----------------