Angular 라우터 재사용 전략을 활용한 탭 구현

Angular 애플리케이션에서 여러 페이지를 탭 형태로 관리하고, 탭 전환 시 각 페이지의 상태를 유지해야 하는 경우가 있습니다. 이는 Angular의 기본 라우팅 동작과 달리, 이미 방문했던 라우트의 컴포넌트 인스턴스를 파괴하지 않고 재사용하는 방식으로 구현할 수 있습니다. 본 글에서는 Angular의 RouteReuseStrategy 인터페이스를 확장하여 탭 기반 캐싱 기능을 구현하는 방법을 상세히 설명합니다.

1. 사용자 정의 라우트 재사용 전략 구현

RouteReuseStrategy 인터페이스는 라우트가 재사용되어야 하는지 여부를 결정하고, 컴포넌트 인스턴스를 캐시하고 복원하는 메서드들을 정의합니다. 이 인터페이스를 구현하는 클래스를 생성하여 탭 캐싱 로직을 만듭니다.

src/app/core/strategies/tab-route-cache.strategy.ts:

import { RouteReuseStrategy, ActivatedRouteSnapshot, DetachedRouteHandle } from '@angular/router';

interface RouteCacheEntry {
  snapshot: ActivatedRouteSnapshot;
  handle: DetachedRouteHandle;
}

export class TabRouteCacheStrategy implements RouteReuseStrategy {
  // 라우트 스냅샷과 컴포넌트 핸들을 저장하는 정적 캐시
  static cachedRouteStates: { [key: string]: RouteCacheEntry } = {};

  /**
   * 라우트가 비활성화될 때, 해당 컴포넌트가 분리(detach)되어 캐시되어야 하는지 결정합니다.
   * 라우트 설정의 `data` 속성에 `reusable: true`가 명시된 경우에만 캐시합니다.
   */
  shouldDetach(route: ActivatedRouteSnapshot): boolean {
    // 지연 로딩 모듈이거나 라우트 설정이 없는 경우는 캐시하지 않습니다.
    if (!route.routeConfig || route.routeConfig.loadChildren) {
      return false;
    }
    // 라우트 데이터에 `reusable: true` 플래그가 설정된 경우 캐시를 허용합니다.
    return route.data && route.data['reusable'] === true;
  }

  /**
   * `shouldDetach`가 `true`를 반환하여 라우트가 분리될 때 호출됩니다.
   * 분리된 라우트 핸들과 스냅샷을 캐시에 저장합니다.
   */
  store(route: ActivatedRouteSnapshot, handle: DetachedRouteHandle): void {
    const routeKey = this.getRouteIdentifier(route);
    TabRouteCacheStrategy.cachedRouteStates[routeKey] = { snapshot: route, handle: handle };
    console.log(`[TabCacheStrategy] '${routeKey}' 라우트 캐시됨`);
  }

  /**
   * 라우트가 활성화될 때, 해당 컴포넌트가 캐시에서 복원(attach)될 수 있는지 결정합니다.
   * 캐시에 해당 라우트의 상태가 존재하는 경우 복원을 허용합니다.
   */
  shouldAttach(route: ActivatedRouteSnapshot): boolean {
    if (!route.routeConfig) {
      return false;
    }
    const routeKey = this.getRouteIdentifier(route);
    return !!TabRouteCacheStrategy.cachedRouteStates[routeKey];
  }

  /**
   * `shouldAttach`가 `true`를 반환하여 라우트가 복원될 때 호출됩니다.
   * 캐시에서 저장된 라우트 핸들을 검색하여 반환합니다.
   */
  retrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle | null {
    if (!route.routeConfig) {
      return null;
    }
    const routeKey = this.getRouteIdentifier(route);
    const cachedEntry = TabRouteCacheStrategy.cachedRouteStates[routeKey];
    console.log(`[TabCacheStrategy] '${routeKey}' 라우트 복원 시도: ${!!cachedEntry}`);
    return cachedEntry?.handle || null;
  }

  /**
   * 새로운 라우트와 현재 라우트가 동일할 때, 라우트를 재사용해야 하는지 결정합니다.
   * 전체 경로(파라미터 포함)가 동일하면 라우트 인스턴스를 재사용합니다.
   */
  shouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot): boolean {
    // 라우트 경로 및 파라미터가 정확히 일치하면 기존 컴포넌트를 재사용합니다.
    return this.getRouteIdentifier(future) === this.getRouteIdentifier(curr);
  }

  /**
   * 라우트의 고유 식별자(키)를 생성합니다.
   * 모든 경로 세그먼트와 쿼리 파라미터를 포함하여 `/details/101?param=value`와 같은 형태로 생성됩니다.
   * 이를 통해 `/details/101`과 `/details/102`와 같은 라우트들을 개별적으로 캐시할 수 있습니다.
   */
  private getRouteIdentifier(route: ActivatedRouteSnapshot): string {
    const segments: string[] = [];
    // 루트부터 현재 라우트까지의 모든 URL 세그먼트 추출
    route.pathFromRoot.forEach(segment => {
      segment.url.forEach(urlSegment => segments.push(urlSegment.path));
    });

    // 쿼리 파라미터도 키에 포함시켜, 쿼리 파라미터가 다른 경우를 구분
    const queryParams = Object.keys(route.queryParams)
      .sort() // 일관성을 위해 정렬
      .map(key => `${key}=${route.queryParams[key]}`)
      .join('&');

    let key = `/${segments.join('/')}`;
    if (queryParams) {
      key += `?${queryParams}`;
    }
    return key;
  }

  /**
   * 캐시에서 특정 라우트를 제거하는 정적 메서드입니다.
   * 탭이 닫힐 때 해당 라우트의 캐시를 삭제하는 데 사용됩니다.
   */
  static removeRouteFromCache(routePath: string): void {
    console.log(`[TabCacheStrategy] '${routePath}' 캐시에서 제거됨`);
    delete TabRouteCacheStrategy.cachedRouteStates[routePath];
  }
}

이 전략은 라우트 설정의 data 속성에 reusable: true가 명시된 라우트만 캐시하도록 합니다. 또한, getRouteIdentifier 메서드는 라우트 경로와 쿼리 파라미터까지 포함한 고유한 키를 생성하여, 동일한 라우트 템플릿이라도 파라미터가 다르면 별도의 캐시 항목으로 관리됩니다 (예: /details/101과 /details/102).

AppModule에 라우트 재사용 전략 등록

구현한 TabRouteCacheStrategy를 Angular의 라우터가 사용하도록 AppModule의 providers에 등록해야 합니다.

src/app/app.module.ts:

import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
import { RouteReuseStrategy } from '@angular/router'; // RouteReuseStrategy 임포트
import { MatTabsModule } from '@angular/material/tabs'; // Material 탭 모듈
import { MatIconModule } from '@angular/material/icon'; // Material 아이콘 모듈
import { FormsModule } from '@angular/forms'; // FormsModule (`textarea`에 필요)

import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';
import { TabRouteCacheStrategy } from './core/strategies/tab-route-cache.strategy'; // 사용자 정의 전략 임포트

// 예시 페이지 컴포넌트들
import { MainLayoutComponent } from './layout/main-layout/main-layout.component';
import { HomePageComponent } from './pages/home/home-page.component';
import { DetailsPageComponent } from './pages/details/details-page.component';
import { ListingPageComponent } from './pages/listing/listing-page.component';

@NgModule({
  declarations: [
    AppComponent,
    MainLayoutComponent,
    HomePageComponent,
    DetailsPageComponent,
    ListingPageComponent
  ],
  imports: [
    BrowserModule,
    BrowserAnimationsModule,
    AppRoutingModule,
    MatTabsModule, // MatTabsModule 추가
    MatIconModule, // MatIconModule 추가
    FormsModule // FormsModule 추가
  ],
  providers: [
    // RouteReuseStrategy를 사용자 정의 전략으로 등록
    { provide: RouteReuseStrategy, useClass: TabRouteCacheStrategy }
  ],
  bootstrap: [AppComponent]
})
export class AppModule { }

라우트 설정에 캐싱 옵션 추가

캐시하려는 라우트의 data 속성에 reusable: true와 함께 탭에 표시될 tabTitle을 추가합니다.

src/app/app-routing.module.ts:

import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { HomePageComponent } from './pages/home/home-page.component';
import { DetailsPageComponent } from './pages/details/details-page.component';
import { ListingPageComponent } from './pages/listing/listing-page.component';
import { MainLayoutComponent } from './layout/main-layout/main-layout.component'; // 레이아웃 컴포넌트 임포트

const routes: Routes = [
  { path: '', redirectTo: 'dashboard/home', pathMatch: 'full' },
  {
    path: 'dashboard',
    component: MainLayoutComponent, // 탭을 관리할 레이아웃 컴포넌트
    children: [
      {
        path: 'home',
        component: HomePageComponent,
        data: { tabTitle: '대시보드 홈', reusable: true } // 캐시 가능하도록 표시
      },
      {
        path: 'details/:id',
        component: DetailsPageComponent,
        data: { tabTitle: '상세 정보', reusable: true } // 캐시 가능하도록 표시
      },
      {
        path: 'list',
        component: ListingPageComponent,
        data: { tabTitle: '목록 보기', reusable: true } // 캐시 가능하도록 표시
      },
      { path: '**', redirectTo: 'home' } // 대시보드 내의 Catch-all
    ]
  },
  // 다른 라우트들을 여기에 추가할 수 있습니다 (캐시되지 않을 수도 있음)
];

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

여기서는 MainLayoutComponent를 최상위 라우트로 설정하고, 그 안에 탭으로 관리될 페이지들을 자식 라우트로 배치했습니다. 이렇게 하면 MainLayoutComponent가 모든 탭을 감싸는 컨테이너 역할을 하게 됩니다.

2. 탭 UI 및 라우팅 관리 컴포넌트 구현

탭을 표시하고, 라우터 이벤트를 감지하여 탭 목록을 업데이트하며, 탭 클릭 및 닫기 이벤트를 처리하는 컴포넌트가 필요합니다.

src/app/layout/main-layout/main-layout.component.ts:

import { Component, OnInit } from '@angular/core';
import { ActivatedRoute, NavigationEnd, Router } from '@angular/router';
import { filter, map } from 'rxjs/operators';
import { TabRouteCacheStrategy } from '../../core/strategies/tab-route-cache.strategy'; // 전략 임포트

// 각 탭의 정보를 담을 인터페이스
interface ManagedTab {
  title: string; // 탭에 표시될 제목
  path: string;  // 탭이 가리키는 라우트 경로
}

@Component({
  selector: 'app-main-layout',
  templateUrl: './main-layout.component.html',
  styleUrls: ['./main-layout.component.scss']
})
export class MainLayoutComponent implements OnInit {
  activeTabs: ManagedTab[] = []; // 현재 활성화된 탭 목록
  currentTabIndex: number = 0; // 현재 선택된 탭의 인덱스

  constructor(
    private router: Router,
    private activatedRoute: ActivatedRoute
  ) {}

  ngOnInit(): void {
    // 라우터 이벤트를 구독하여 탭 목록을 관리합니다.
    this.router.events.pipe(
      filter(event => event instanceof NavigationEnd), // NavigationEnd 이벤트만 필터링
      map(() => this.activatedRoute), // 현재 활성화된 라우트 스냅샷 가져오기
      map(route => {
        // 라우트가 중첩될 수 있으므로, 가장 하위의 활성화된 라우트를 찾습니다.
        while (route.firstChild) {
          route = route.firstChild;
        }
        return route;
      }),
      filter(route => route.outlet === 'primary') // 'primary' 아웃렛의 라우트만 처리
    ).subscribe((routeSnapshot: ActivatedRouteSnapshot) => {
      const routePath = this.getRoutePathWithParams(routeSnapshot); // 현재 라우트의 전체 경로와 파라미터 가져오기
      const tabTitle = routeSnapshot.data['tabTitle']; // 라우트 데이터에서 탭 제목 가져오기

      if (!tabTitle) {
        console.log('tabTitle 데이터가 없는 라우트는 탭으로 추가되지 않습니다.');
        return; // `tabTitle`이 없는 라우트는 탭으로 생성하지 않음
      }

      const existingTabIndex = this.activeTabs.findIndex(tab => tab.path === routePath);

      if (existingTabIndex !== -1) {
        // 이미 존재하는 탭이라면 해당 탭을 활성화
        this.currentTabIndex = existingTabIndex;
      } else {
        // 새로운 탭이라면 목록에 추가하고 활성화
        this.activeTabs.push({ title: tabTitle, path: routePath });
        this.currentTabIndex = this.activeTabs.length - 1;
      }
    });
  }

  /**
   * `TabRouteCacheStrategy`와 동일한 방식으로 라우트의 전체 경로를 파라미터와 함께 구성합니다.
   */
  private getRoutePathWithParams(route: ActivatedRouteSnapshot): string {
    const segments: string[] = [];
    route.pathFromRoot.forEach(segment => {
      segment.url.forEach(urlSegment => segments.push(urlSegment.path));
    });
    const queryParams = Object.keys(route.queryParams).sort().map(key => `${key}=${route.queryParams[key]}`).join('&');
    let key = `/${segments.join('/')}`;
    if (queryParams) {
      key += `?${queryParams}`;
    }
    return key;
  }

  /**
   * 탭 클릭 시 해당 라우트로 이동합니다.
   * `mat-tab-group`의 `selectedIndexChange` 이벤트와 `mat-tab-label` 내의 `click` 이벤트 모두에서 사용됩니다.
   */
  selectTab(path: string): void {
    this.router.navigateByUrl(path);
  }

  /**
   * 탭을 닫고 캐시된 라우트 상태를 제거합니다.
   * 닫히는 탭이 현재 활성화된 탭인 경우, 다른 탭으로 자동으로 전환됩니다.
   */
  closeTab(event: MouseEvent, pathToClose: string): void {
    event.stopPropagation(); // `mat-tab-label`의 클릭 이벤트가 발생하지 않도록 합니다.

    if (this.activeTabs.length === 1) {
      console.log('마지막 탭은 닫을 수 없습니다.');
      return;
    }

    const indexToClose = this.activeTabs.findIndex(tab => tab.path === pathToClose);
    if (indexToClose === -1) return;

    // UI 탭 목록에서 제거
    this.activeTabs.splice(indexToClose, 1);

    // 캐시된 라우트 상태 제거 (핵심!)
    TabRouteCacheStrategy.removeRouteFromCache(pathToClose);

    // 다른 탭으로 이동 처리
    let navigatePath: string;
    if (pathToClose === this.getRoutePathWithParams(this.activatedRoute.firstChild!)) {
      // 닫는 탭이 현재 활성화된 탭인 경우
      // 이전 탭이나 첫 번째 탭으로 이동합니다.
      const newActiveIndex = indexToClose > 0 ? indexToClose - 1 : 0;
      this.currentTabIndex = newActiveIndex; // UI 탭 인덱스 업데이트
      navigatePath = this.activeTabs[newActiveIndex].path;
    } else {
      // 활성화되지 않은 탭을 닫은 경우, 인덱스만 조정합니다.
      if (indexToClose < this.currentTabIndex) {
        this.currentTabIndex--;
      }
      navigatePath = this.activeTabs[this.currentTabIndex].path;
    }
    this.router.navigateByUrl(navigatePath);
  }
}

MainLayoutComponent의 HTML 템플릿

탭 내비게이션을 위한 Material Design 탭 그룹과 라우트 콘텐츠를 표시할 <router-outlet>을 사용합니다.

src/app/layout/main-layout/main-layout.component.html:

<div class="app-container">
  <header class="app-header">
    <h1>Angular 탭 라우팅 캐싱 예제</h1>
  </header>

  <div class="content-area">
    <nav class="sidebar">
      <h2>내비게이션</h2>
      <ul>
        <li><a routerLink="/dashboard/home" routerLinkActive="active">홈 페이지</a></li>
        <li><a routerLink="/dashboard/details/101" routerLinkActive="active">상세 정보 (ID: 101)</a></li>
        <li><a routerLink="/dashboard/details/102" routerLinkActive="active">상세 정보 (ID: 102)</a></li>
        <li><a routerLink="/dashboard/list" routerLinkActive="active">목록 페이지</a></li>
      </ul>
    </nav>

    <main class="router-main">
      <!-- Angular Material 탭 그룹 -->
      <mat-tab-group [selectedIndex]="currentTabIndex" (selectedIndexChange)="selectTab(activeTabs[$event].path)">
        <mat-tab *ngFor="let tab of activeTabs; let i = index">
          <!-- 탭 라벨 커스터마이징 -->
          <ng-template mat-tab-label>
            <span class="tab-label-text" (click)="selectTab(tab.path)">{{ tab.title }}</span>
            <button mat-icon-button (click)="closeTab($event, tab.path)" class="tab-close-button">
              <mat-icon>close</mat-icon>
            </button>
          </ng-template>
        </mat-tab>
      </mat-tab-group>

      <div class="router-outlet-container">
        <!-- 캐시된 컴포넌트가 로드될 라우터 아웃렛 -->
        <router-outlet></router-outlet>
      </div>
    </main>
  </div>
</div>

MainLayoutComponent의 스타일 (SCSS)

탭과 전체 레이아웃의 기본적인 스타일링을 정의합니다.

src/app/layout/main-layout/main-layout.component.scss:

/* main-layout.component.scss */
.app-container {
  display: flex;
  flex-direction: column;
  height: 100vh;
  font-family: Arial, sans-serif;
  background-color: #f0f2f5;
}

.app-header {
  background-color: #3f51b5;
  color: white;
  padding: 15px 20px;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
  h1 {
    margin: 0;
    font-size: 1.5rem;
  }
}

.content-area {
  display: flex;
  flex: 1;
  overflow: hidden;
}

.sidebar {
  width: 200px;
  background-color: #ffffff;
  padding: 20px;
  box-shadow: 2px 0 5px rgba(0, 0, 0, 0.05);
  flex-shrink: 0; /* 사이드바 크기 고정 */
  h2 {
    margin-top: 0;
    color: #3f51b5;
    font-size: 1.2rem;
    border-bottom: 1px solid #e0e0e0;
    padding-bottom: 10px;
    margin-bottom: 15px;
  }
  ul {
    list-style: none;
    padding: 0;
    margin: 0;
    li {
      margin-bottom: 10px;
      a {
        text-decoration: none;
        color: #333;
        font-weight: 500;
        display: block;
        padding: 8px 10px;
        border-radius: 4px;
        transition: background-color 0.2s ease;
        &:hover {
          background-color: #e0e0e0;
        }
        &.active {
          background-color: #bbdefb;
          color: #1a237e;
        }
      }
    }
  }
}

.router-main {
  flex: 1;
  display: flex;
  flex-direction: column;
  padding: 20px;
  overflow: auto; /* 메인 콘텐츠 영역 스크롤 가능 */
}

.router-outlet-container {
  flex: 1;
  background-color: #ffffff;
  border: 1px solid #ddd;
  border-radius: 8px;
  padding: 20px;
  margin-top: 10px;
  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08);
  overflow: auto;
}

/* Angular Material Tab 기본 스타일 오버라이드 */
::ng-deep {
  .mat-tab-group {
    height: 48px; /* 표준 탭 높이 */
    .mat-tab-header {
      border-bottom: 1px solid #e0e0e0;
    }
    .mat-tab-labels {
      .mat-tab-label {
        min-width: 120px;
        padding: 0 16px;
        background-color: #f5f5f5;
        border-right: 1px solid #eee;
        border-top-left-radius: 8px;
        border-top-right-radius: 8px;
        margin-right: 2px; /* 탭 사이의 작은 간격 */
        transition: background-color 0.2s ease;

        &:hover {
          background-color: #e0e0e0;
        }

        &.mat-tab-label-active {
          background-color: #ffffff;
          border-top: 2px solid #3f51b5;
          border-right: 1px solid transparent;
          color: #3f51b5;
          margin-top: -2px; /* 활성 탭을 살짝 들어 올림 */
          padding-top: 2px;
        }
      }
    }
    .mat-tab-body-wrapper {
      display: none; /* 기본 탭 바디를 숨기고, router-outlet 사용 */
    }
  }
}

.tab-label-text {
  cursor: pointer;
  padding-right: 8px; /* 닫기 버튼과의 공간 */
}

.tab-close-button {
  min-width: 24px;
  width: 24px;
  height: 24px;
  line-height: 24px;
  padding: 0;
  margin-left: 4px;
  font-size: 16px;
  color: #757575;
  &:hover {
    background-color: #ccc;
    color: #333;
  }
}

3. 예시 페이지 컴포넌트

탭 캐싱이 실제로 동작하는 것을 확인하기 위한 간단한 페이지 컴포넌트들입니다. 각 컴포넌트 내의 상태(예: 입력 필드 값, 스크롤 위치, 카운터)가 탭 전환 시에도 유지되는지 확인할 수 있습니다.

src/app/pages/home/home-page.component.ts:

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

@Component({
  selector: 'app-home-page',
  template: `
    <h2>홈 페이지</h2>
    <p>환영합니다! 이 페이지는 한 번 로드되면 캐시되어 상태가 유지됩니다.</p>
    <p>현재 시간: {{ currentTime }}</p>
    <button mat-raised-button color="primary" (click)="updateTime()">시간 업데이트</button>
  `,
  styles: [`
    h2 { color: #3f51b5; }
    p { margin-bottom: 10px; }
    button { margin-top: 10px; }
  `]
})
export class HomePageComponent {
  currentTime: string;
  constructor() {
    this.currentTime = new Date().toLocaleTimeString();
  }
  updateTime() {
    this.currentTime = new Date().toLocaleTimeString();
  }
}

src/app/pages/details/details-page.component.ts:

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

@Component({
  selector: 'app-details-page',
  template: `
    <h2>상세 정보 페이지 (ID: {{ detailId }})</h2>
    <p>선택된 상세 정보 ID: <strong>{{ detailId }}</strong></p>
    <p>이 페이지는 ID에 따라 별도로 캐시됩니다. 다른 ID로 이동해보세요.</p>
    <textarea [(ngModel)]="content" rows="5" cols="50" placeholder="여기에 내용을 입력하면 탭 전환 시에도 내용이 유지됩니다."></textarea>
    <button mat-raised-button color="accent" (click)="saveContent()">내용 저장 (로컬 스토리지)</button>
  `,
  styles: [`
    h2 { color: #3f51b5; }
    textarea { width: 100%; margin-top: 10px; border: 1px solid #ccc; padding: 8px; border-radius: 4px; }
    button { margin-top: 10px; }
  `]
})
export class DetailsPageComponent implements OnInit {
  detailId: string | null = null;
  content: string = '';

  constructor(private route: ActivatedRoute) {}

  ngOnInit(): void {
    // 라우트 파라미터 변경을 구독하여 상세 정보 ID 업데이트
    this.route.paramMap.subscribe(params => {
      this.detailId = params.get('id');
      // ID에 따라 로컬 스토리지에서 이전 내용 로드 (데모용)
      this.content = localStorage.getItem(`detailContent_${this.detailId}`) || '';
    });
  }

  saveContent(): void {
    if (this.detailId) {
      localStorage.setItem(`detailContent_${this.detailId}`, this.content);
      alert('내용이 저장되었습니다!');
    }
  }
}

src/app/pages/listing/listing-page.component.ts:

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

@Component({
  selector: 'app-listing-page',
  template: `
    <h2>목록 페이지</h2>
    <p>여기에 긴 목록이 있다고 가정합니다. 스크롤 위치를 유지하는지 확인해보세요.</p>
    <div class="scroll-container">
      <p *ngFor="let item of items">{{ item }}</p>
    </div>
    <p>페이지 방문 횟수: <strong>{{ visitCount }}</strong></p>
    <button mat-raised-button color="warn" (click)="incrementVisit()">방문 횟수 증가</button>
  `,
  styles: [`
    h2 { color: #3f51b5; }
    .scroll-container {
      height: 200px;
      overflow-y: scroll;
      border: 1px solid #ccc;
      padding: 10px;
      background-color: #f9f9f9;
      border-radius: 4px;
      margin-bottom: 10px;
    }
    p { margin: 5px 0; }
    button { margin-top: 10px; }
  `]
})
export class ListingPageComponent implements OnInit {
  items: string[] = [];
  visitCount: number = 0;

  constructor() {
    for (let i = 1; i <= 50; i++) {
      this.items.push(`목록 항목 ${i}`);
    }
  }

  ngOnInit(): void {
    // 컴포넌트가 초기화되거나 캐시에서 복원될 때마다 방문 횟수 증가
    this.visitCount++;
  }

  incrementVisit(): void {
    this.visitCount++;
  }
}

태그: Angular router RouteReuseStrategy TabbedNavigation ComponentCaching

10월 28일 04:45에 게시됨