如何让页面等待缓存读取完成后再加载？Angular应用同步问题

我来给你几个实战中常用的解决思路，都是针对这类异步数据预加载问题的：

方案1：用APP_INITIALIZER阻塞应用初始化（推荐全局数据预加载） #

这个方法会让Angular在启动应用之前等待你的API请求完成并写入缓存，从根源上避免缓存未就绪的问题。

首先把你头部的AJAX请求改成返回Promise的函数：

// 全局环境下的函数（比如index.html的script里）
function fetchAndCacheApiData() {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open('GET', '你的API地址');
    xhr.responseType = 'json';
    
    xhr.onload = () => {
      if (xhr.status >= 200 && xhr.status < 300) {
        localStorage.setItem('apiCache', JSON.stringify(xhr.response));
        resolve(xhr.response);
      } else {
        reject(new Error(`API请求失败，状态码：${xhr.status}`));
      }
    };
    
    xhr.onerror = () => reject(new Error('网络请求出错'));
    xhr.send();
  });
}

然后在Angular的根模块（AppModule）里配置APP_INITIALIZER，让它等待这个Promise完成后再启动应用：

import { NgModule, APP_INITIALIZER } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { AppComponent } from './app.component';

// 定义初始化函数
export function initAppData() {
  // 调用全局的fetch函数
  return () => window.fetchAndCacheApiData();
}

@NgModule({
  declarations: [AppComponent],
  imports: [BrowserModule],
  providers: [
    {
      provide: APP_INITIALIZER,
      useFactory: initAppData,
      multi: true // 允许多个初始化器
    }
  ],
  bootstrap: [AppComponent]
})
export class AppModule { }

这样Angular启动时会自动等待API请求完成并写入缓存，你在组件里直接读取localStorage.getItem('apiCache')就一定能拿到数据了。

方案2：自定义事件通知+组件等待渲染（适合非全局数据） #

如果不想阻塞整个应用初始化，只想让需要数据的组件等待，可以用自定义事件来通知缓存就绪：

首先修改头部的AJAX请求，完成后派发全局事件：

xhr.onload = () => {
  if (xhr.status >= 200 && xhr.status < 300) {
    const data = xhr.response;
    localStorage.setItem('apiCache', JSON.stringify(data));
    // 派发自定义事件，携带数据
    window.dispatchEvent(new CustomEvent('apiDataCached', { detail: data }));
  }
};

然后在需要数据的Angular组件里，先检查缓存，没有的话就监听事件：

import { Component, OnInit } from '@angular/core';

@Component({
  selector: 'app-main-content',
  template: `
    <!-- 数据就绪前显示加载态 -->
    <div *ngIf="!isDataReady" class="loading">加载中...</div>
    
    <!-- 数据就绪后渲染内容 -->
    <div *ngIf="isDataReady">
      <!-- 这里用cachedData构建DOM -->
      <h1>{{ cachedData.title }}</h1>
    </div>
  `
})
export class MainContentComponent implements OnInit {
  isDataReady = false;
  cachedData: any;

  ngOnInit() {
    // 先检查缓存是否已有数据
    const storedData = localStorage.getItem('apiCache');
    if (storedData) {
      this.cachedData = JSON.parse(storedData);
      this.isDataReady = true;
    } else {
      // 监听缓存就绪事件
      window.addEventListener('apiDataCached', (event: CustomEvent) => {
        this.cachedData = event.detail;
        this.isDataReady = true;
      });
    }
  }
}

这个方案更灵活，页面其他部分可以正常加载，只有需要数据的区域等待。

方案3：路由Resolve守卫（适合路由级数据预加载） #

如果是特定路由需要这个API数据，可以用Angular的路由Resolve守卫，确保进入路由前数据已经准备好：

首先创建一个数据服务，把AJAX请求移到服务里（推荐用Angular的HttpClient）：

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

@Injectable({ providedIn: 'root' })
export class ApiDataService {
  constructor(private http: HttpClient) {}

  getCachedData(): Observable<any> {
    // 先读缓存
    const cached = localStorage.getItem('apiCache');
    if (cached) {
      return of(JSON.parse(cached));
    }
    // 缓存没有就请求API，并存入缓存
    return this.http.get('你的API地址').pipe(
      tap(data => localStorage.setItem('apiCache', JSON.stringify(data)))
    );
  }
}

然后创建Resolve守卫：

import { Injectable } from '@angular/core';
import { Resolve, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
import { ApiDataService } from './api-data.service';
import { Observable } from 'rxjs';

@Injectable({ providedIn: 'root' })
export class DataResolveGuard implements Resolve<any> {
  constructor(private dataService: ApiDataService) {}

  resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<any> {
    return this.dataService.getCachedData();
  }
}

最后在路由配置里使用这个守卫：

import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { TargetComponent } from './target/target.component';
import { DataResolveGuard } from './data-resolve.guard';

const routes: Routes = [
  {
    path: 'target-page',
    component: TargetComponent,
    resolve: { apiData: DataResolveGuard } // 进入路由前获取数据
  }
];

@NgModule({
  imports: [RouterModule.forRoot(routes)],
  exports: [RouterModule]
})
export class AppRoutingModule { }

在目标组件里通过路由快照获取数据：

import { Component, OnInit } from '@angular/core';
import { ActivatedRoute } from '@angular/router';

@Component({
  selector: 'app-target',
  template: `
    <div>{{ apiData.title }}</div>
  `
})
export class TargetComponent implements OnInit {
  apiData: any;

  constructor(private route: ActivatedRoute) {}

  ngOnInit() {
    // 从路由解析结果中获取数据
    this.apiData = this.route.snapshot.data['apiData'];
  }
}

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