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++;
}
}