BehaviorSubject与RxJS订阅问题全解析

还在为Angular中RxJS的BehaviourSubject感到困惑吗？本文深入解析了`BehaviourSubject`的常见误解，例如为何在没有调用`next()`方法时视图依然更新，以及多重订阅导致重复日志的问题。通过剖析RxJS的订阅机制和JavaScript引用类型，揭示了视图更新的深层原因。本文不仅提供了避免重复订阅和正确更新视图的最佳实践，还强调了在响应式编程中发出新数据引用的重要性，助力开发者构建更健壮、高效的Angular应用，避免潜在的性能陷阱，特别是在使用`OnPush`变更检测策略时。掌握这些技巧，让你的Angular开发更上一层楼！

1. RxJS订阅机制与重复日志问题

在使用RxJS时，理解其订阅（Subscription）的工作方式至关重要。一个常见的误解是，每次调用next()方法时都需要重新订阅。然而，RxJS的可观察对象（Observable）和主题（Subject）在订阅后会持续监听值的发射，直到被取消订阅。

考虑以下简单的Subject示例：

import { Subject } from 'rxjs';
import { tap } from 'rxjs/operators';

export class MyComponent implements OnInit {
  exampleSubject = new Subject();

  ngOnInit(): void {
    // 第一次订阅：在组件初始化时订阅一次
    this.exampleSubject.pipe(
      tap(value => console.log('Subscription 1:', value))
    ).subscribe();
  }

  emitValue(value: string) {
    this.exampleSubject.next(value);
  }
}

在这个例子中，console.log只会因为emitValue()方法中调用this.exampleSubject.next("text")而触发一次。订阅是在ngOnInit中建立的，它会一直存在，每次next()被调用时都会执行其回调。

重复订阅的后果：

如果在一个事件处理器（例如按钮点击）中重复创建订阅，而不是仅在初始化时订阅一次，就会导致每次事件触发时都增加一个新的监听器。

import { BehaviorSubject, Observable, Subject } from 'rxjs';
import { tap } from 'rxjs/operators';
import { HttpClient } from '@angular/common/http';
import { Injectable, OnInit } from '@angular/core';

// 假设的ITask接口
interface ITask {
  id: string;
  isImportant: boolean;
  text: string;
}

// 原始问题中的AppComponent片段，演示了重复订阅
export class AppComponent implements OnInit {
  public tasks!: BehaviorSubject;
  constructor(private _tasksService: TasksService) {}

  ngOnInit(): void {
    console.log('OnInit');
    this.tasks = this._tasksService.getTasks();
  }

  public addTask() {
    this._tasksService.addTask({
      id: crypto.randomUUID(),
      isImportant: true,
      text: 'Added task'
    });

    // 错误示范：每次点击按钮都创建新的订阅
    this.tasks.pipe(tap((value) => console.log(value))).subscribe();
  }
}

在上述AppComponent的addTask()方法中，每次点击“Add Task”按钮时，都会执行this.tasks.pipe(tap(...)).subscribe();。这意味着：

• 第一次点击：创建1个订阅。
• 第二次点击：创建第2个订阅（总共2个）。
• 第三次点击：创建第3个订阅（总共3个）。

因此，当_tasksService中的BehaviourSubject发出值时，所有已存在的订阅都会被触发，导致console.log被多次打印，且每次点击都会增加打印次数。

BehaviourSubject的特性：

BehaviourSubject是一种特殊类型的主题，它总是保存其最新发出的值。当一个新的订阅者订阅BehaviourSubject时，它会立即接收到当前保存的值，然后才接收后续发出的值。这就是为什么即使你没有调用next()，但每次重复订阅时，console.log仍然会至少打印一次（即BehaviourSubject的当前值）。

解决方案：

为了避免重复的控制台日志和不必要的资源消耗，应该只订阅一次。通常，这会在组件的ngOnInit生命周期钩子中完成。

// 修正后的AppComponent片段
export class AppComponent implements OnInit {
  public tasks!: BehaviorSubject; // 注意：这里通常直接订阅，而不是持有Subject本身
  public taskList: ITask[] = []; // 用于在模板中迭代的数组

  constructor(private _tasksService: TasksService) {}

  ngOnInit(): void {
    console.log('OnInit');
    // 正确的做法：在ngOnInit中订阅一次，并将值赋给本地属性
    this._tasksService.getTasks().pipe(
      tap(tasks => console.log('Tasks updated:', tasks)) // 仅在此处进行日志记录
    ).subscribe(tasks => {
      this.taskList = tasks; // 将最新任务列表赋值给本地属性
    });
  }

  public addTask() {
    this._tasksService.addTask({
      id: crypto.randomUUID(),
      isImportant: true,
      text: 'Added task'
    });
    // 不再在此处创建新的订阅
  }
}

在HTML模板中，如果使用async管道，它会自动处理订阅和取消订阅，无需手动管理：

 
    {{task.text}}
    {{task.id}}

Add Task

或者，如果想直接使用async管道，确保tasks属性是一个Observable，并且服务中的getTasks()返回的是_tasks$本身：

// AppComponent
export class AppComponent implements OnInit {
  public tasks$: Observable; // 声明为Observable
  constructor(private _tasksService: TasksService) {}

  ngOnInit(): void {
    this.tasks$ = this._tasksService.getTasks(); // 直接获取Observable
    // 如果需要日志，可以在这里订阅，或者在服务中处理
    this.tasks$.pipe(
      tap(tasks => console.log('Tasks via async pipe:', tasks))
    ).subscribe(); // 仅用于日志，async pipe会自行管理订阅
  }

  public addTask() {
    this._tasksService.addTask({
      id: crypto.randomUUID(),
      isImportant: true,
      text: 'Added task'
    });
  }
}

// HTML模板

    {{task.text}}
    {{task.id}}

Add Task

2. BehaviourSubject与JavaScript引用类型

第二个问题是，即使没有调用_tasks$.next(this._tasks)，视图仍然会更新。这涉及到JavaScript中引用类型（如数组和对象）的工作原理以及Angular的变更检测机制。

在服务中，_tasks$这个BehaviourSubject持有对_tasks数组的引用：

@Injectable({
  providedIn: 'root'
})
export class TasksService {
  private _tasks: ITask[] = [];
  private _tasks$: BehaviorSubject = new BehaviorSubject([]);
  constructor(private _http: HttpClient) { }

  public getTasks() {
    this.getTasksObservableFromDb().pipe(
      tap(
        (tasks) => {
          this._tasks = tasks;
          this._tasks$.next(tasks); // 首次从DB获取后，将引用传递给BehaviourSubject
        }
      )
    ).subscribe();
    return this._tasks$;
  }

  public addTask(task: ITask) {
    this._tasks.push(task); // 直接修改了_tasks数组
    // this._tasks$.next(this._tasks); // 原始问题中被删除的行
  }

  // ... 其他方法
}

当getTasks()方法首次执行时，this._tasks$.next(tasks)将_tasks数组的引用传递给了_tasks$。这意味着_tasks$现在“指向”与_tasks变量相同的内存地址。

当addTask(task: ITask)方法被调用时，this._tasks.push(task)操作直接修改了_tasks数组在内存中的内容。由于_tasks$持有的是这个数组的引用，它所指向的数组内容也随之改变。

为什么视图会更新？

即使_tasks$.next()没有被调用，BehaviourSubject本身并不会发出新的值。然而，Angular的默认变更检测策略（ChangeDetectionStrategy.Default）会在每次异步事件（如HTTP请求完成、定时器、用户交互事件等）发生时运行。

当addTask()方法被调用，_tasks.push(task)修改了数组内容，然后Angular的变更检测机制被触发。由于*ngFor="let task of tasks | async"绑定到的是tasks（它通过async管道获取到_tasks$所持有的数组引用），Angular会重新评估这个绑定。尽管数组的引用没有改变，但Angular会检测到该引用所指向的数组内容发生了变化（因为多了一个元素），从而更新DOM以反映这些变化。

最佳实践：始终发出新的引用

虽然Angular的默认变更检测可以捕捉到这种内部变化，但在响应式编程中，最佳实践是当数据发生变化时，总是通过next()方法发出一个新的数据实例。这有几个重要的好处：

1. 明确的数据流： 消费者可以明确知道何时有新的数据可用。
2. 兼容OnPush策略： 如果组件使用ChangeDetectionStrategy.OnPush，它只会在输入属性引用发生变化或可观察对象发出新值时才进行变更检测。在这种情况下，不发出新引用会导致视图不更新。
3. 避免意外副作用： 确保每次发射的数据都是一个新的、不可变的状态，可以避免在其他地方无意中修改了共享的数据。

为了遵循最佳实践，addTask方法应该修改为：

export class TasksService {
  // ...
  public addTask(task: ITask) {
    // 创建一个新的数组，包含旧元素和新元素，然后发出这个新数组的引用
    this._tasks = [...this._tasks, task];
    this._tasks$.next(this._tasks); // 发出新的数组引用
  }

  // 或者更简洁地直接操作并发出副本
  public addTaskV2(task: ITask) {
    const updatedTasks = [...this._tasks, task]; // 创建新数组
    this._tasks = updatedTasks; // 更新内部状态
    this._tasks$.next(updatedTasks); // 发出新数组
  }
}

通过[...this._tasks, task]这种方式，我们创建了一个全新的数组实例，其中包含了所有旧任务和新添加的任务。然后，将这个新数组的引用传递给_tasks$.next()，这样BehaviourSubject就会发出一个全新的值，确保所有订阅者都能接收到这个明确的更新信号。

总结

理解RxJS的订阅生命周期和JavaScript的引用类型是构建高性能、可维护的Angular应用的关键。避免在事件处理器中重复订阅，并确保当数据内容发生变化时，通过next()方法发出新的数据引用，将有助于你更好地利用RxJS的强大功能，并避免潜在的变更检测问题，尤其是在使用OnPush变更检测策略时。

好了，本文到此结束，带大家了解了《BehaviorSubject与RxJS订阅问题全解析》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！