HarmonyOS 6.0应用级事件总线与组件间通信实例详解_ar

前言

组件通信有@prop/@link、@provide/@consume、@watch这些"正规军"。但有些场景它们搞不定——跨ability通信、非父子组件通信、一对多广播、解耦通信。这时候就得用事件总线。harmonyos提供了emitter和commonevent两套方案，分别管应用内和应用间，但很多人分不清什么时候用哪个。

通信方案对比

方案	通信范围	耦合度	适用场景
@prop/@link	父子组件	高	父子数据同步
@provide/@consume	跨层级	中	祖孙组件通信
appstorage	全局	中	全局状态共享
emitter	应用内任意	低	组件间解耦通信
commonevent	跨应用	低	系统事件、跨应用通知

emitter是应用内的事件总线，commonevent是系统级的事件广播。 大多数场景用emitter就够了，commonevent只在需要跟系统或其他应用通信时才用。

emitter基础

emitter是@kit.basicserviceskit提供的进程内事件机制：

import { emitter } from '@kit.basicserviceskit';

// 定义事件id
const event_login_success = 1001;
const event_cart_updated = 1002;

// 发送事件
emitter.emit({
  eventid: event_login_success,
  parameters: { userid: '12345', username: '张三' }
});

// 接收事件
emitter.on({
  eventid: event_login_success
}, (eventdata: emitter.eventdata) => {
  let params = eventdata.parameters;
  let userid = params['userid'] as string;
  this.onloginsuccess(userid);
});

eventid是数字类型的事件标识，自己定义。parameters携带数据，类型是record<string, object>。

关键：emitter是进程内的，同一个应用内才能收发。 跨进程（不同ability运行在不同进程）时emitter不生效。

emitter取消订阅

// 订阅时保存回调引用
private logincallback = (eventdata: emitter.eventdata) => {
  // 处理
}

abouttoappear(): void {
  emitter.on({ eventid: event_login_success }, this.logincallback);
}

abouttodisappear(): void {
  emitter.off(event_login_success, this.logincallback);
}

必须在abouttodisappear中off取消订阅，否则组件销毁后回调还在执行，导致内存泄漏和空引用crash。

off必须传跟on相同的回调函数引用。所以回调不能写成匿名函数，要保存为类成员变量。

一对多广播

emitter天然支持一对多——多个组件订阅同一个eventid，emit时所有订阅者都会收到：

// 购物车页面
emitter.emit({ eventid: event_cart_updated, parameters: { count: 5 } });

// tabbar组件
emitter.on({ eventid: event_cart_updated }, (data) => {
  this.cartbadge = data.parameters['count'] as number;
});

// 首页组件
emitter.on({ eventid: event_cart_updated }, (data) => {
  this.refreshrecommendations();
});

// 消息中心
emitter.on({ eventid: event_cart_updated }, (data) => {
  this.checkpromotions();
});

三个组件同时监听购物车更新事件，emit一次，三个都收到。这是@prop/@link做不到的——它们需要组件有明确的层级关系。

登录状态同步

经典场景：登录成功后，多个页面需要更新状态：

const event_user_state_changed = 2001;

// 登录页
async login(username: string, password: string): promise<void> {
  let user = await this.authservice.login(username, password);
  appstorage.setorcreate('currentuser', user);
  emitter.emit({
    eventid: event_user_state_changed,
    parameters: { islogin: true, userid: user.id }
  });
}

// 退出登录
logout(): void {
  this.authservice.logout();
  appstorage.delete('currentuser');
  emitter.emit({
    eventid: event_user_state_changed,
    parameters: { islogin: false }
  });
}

// 个人中心页
abouttoappear(): void {
  emitter.on({ eventid: event_user_state_changed }, this.onuserstatechanged);
}

private onuserstatechanged = (data: emitter.eventdata) => {
  let islogin = data.parameters['islogin'] as boolean;
  if (islogin) {
    this.showuserinfo();
  } else {
    this.showloginbutton();
  }
}

为什么不直接用appstorage？ appstorage的数据变化会触发ui刷新，但不会触发逻辑回调。比如退出登录时你不仅要更新ui，还要清理缓存、取消请求、重置状态——这些是业务逻辑，不是ui渲染。emitter可以触发这些逻辑回调。

封装事件总线

直接用emitter的api有点啰嗦。封装一个类型安全的事件总线：

class eventbus {
  private static instance: eventbus;
  private handlers: map<number, emitter.callback[]> = new map();
  static getinstance(): eventbus {
    if (!eventbus.instance) {
      eventbus.instance = new eventbus();
    }
    return eventbus.instance;
  }
  on(eventid: number, callback: emitter.callback): void {
    let existing = this.handlers.get(eventid);
    if (existing === undefined) {
      existing = [];
    }
    existing.push(callback);
    this.handlers.set(eventid, existing);
    emitter.on({ eventid: eventid }, callback);
  }
  off(eventid: number, callback: emitter.callback): void {
    let existing = this.handlers.get(eventid);
    if (existing !== undefined) {
      let newlist: emitter.callback[] = [];
      for (let i = 0; i < existing.length; i++) {
        if (existing[i] !== callback) {
          newlist.push(existing[i]);
        }
      }
      this.handlers.set(eventid, newlist);
    }
    emitter.off(eventid, callback);
  }
  emit(eventid: number, parameters?: record<string, object>): void {
    if (parameters !== undefined) {
      emitter.emit({ eventid: eventid, parameters: parameters });
    } else {
      emitter.emit({ eventid: eventid });
    }
  }
}

封装后使用更简洁：

eventbus.getinstance().on(event_login, this.onlogin);
eventbus.getinstance().emit(event_login, { userid: '123' });
eventbus.getinstance().off(event_login, this.onlogin);

commonevent跨应用通信

commonevent是系统级广播，可以跨应用、跨进程：

import { commoneventmanager } from '@kit.basicserviceskit';

// 订阅系统事件
let subscriber = commoneventmanager.createsubscriber({
  events: ['usual.event.screen_off']
});

commoneventmanager.subscribe(subscriber, (err, data) => {
  // 处理屏幕关闭事件
});

// 取消订阅
commoneventmanager.unsubscribe(subscriber);

commonevent需要权限声明。 很多系统事件需要对应权限才能订阅。自定义事件不需要权限，但要确保事件名的唯一性——建议用包名作前缀：

let custom_event = 'com.example.app.order_created';

commonevent发送

发送自定义commonevent：

commoneventmanager.publish('com.example.app.order_created', {
  parameters: {
    orderid: '20240101001',
    amount: 99.9
  }
}, (err) => {
  if (!err) {
    console.info('event published');
  }
});

publish是异步的，回调在发送完成后触发。

注意：commonevent的发送和接收可以在不同应用中。 这意味着你的事件可能被其他应用监听到，敏感数据不要直接放在parameters里。

什么时候用commonevent

commonevent的使用场景很明确：

监听系统事件：屏幕开关、网络变化、时区变化、电量变化
跨应用通知：支付应用通知订单完成，地图应用接收导航请求
多进程通信：同一个应用的uiability和extensionability在不同进程

应用内通信不要用commonevent——它比emitter重得多（涉及跨进程序列化），而且有权限和可见性问题。

时序控制

事件到达顺序不保证。如果a事件必须在b事件之前处理：

const event_step1_complete = 3001;

// a完成后发事件
emitter.emit({ eventid: event_step1_complete });

// b等a完成才执行
emitter.on({ eventid: event_step1_complete }, () => {
  this.executestep2();
});

用事件链代替时序假设——a完成后emit通知，b监听通知再执行。不要假设emit是同步的。

内存泄漏防护

emitter的回调如果不off，组件销毁后依然执行。最危险的情况：

// 危险：匿名函数无法off
emitter.on({ eventid: 1001 }, (data) => {
  this.updateui(); // 组件已销毁，this可能无效
});

// 安全：保存引用，组件销毁时off
private handler = (data: emitter.eventdata) => {
  this.updateui();
}

abouttoappear(): void {
  emitter.on({ eventid: 1001 }, this.handler);
}

abouttodisappear(): void {
  emitter.off(1001, this.handler);
}

规则：on和off必须成对出现，回调必须是类成员变量，不能是匿名函数。

踩坑清单

问题	原因	解决
组件销毁后crash	没off取消订阅	abouttodisappear中off
off不掉	匿名函数无法比较引用	回调保存为类成员变量
事件收不到	emitter跨进程不生效	跨进程用commonevent
收到重复事件	多次on同一回调	on前先off
事件顺序不对	emit不保证同步时序	用事件链传递顺序
commonevent收不到	没声明权限	检查module.json5权限
自定义事件被拦截	事件名不够唯一	用包名作前缀
参数类型丢失	parameters反序列化	只传基本类型
数据敏感泄露	commonevent跨应用可见	敏感数据加密或用emitter
事件总线内存增长	map中回调越积越多	off时清理map记录