15.Next.js와 Nest.js 연동하여 데이터 가져오기, 블로그 목록 페이지와 상세 페이지에 데이터 연결하기

이번 글에서는 Next.jsNest.js를 활용하여 블로그 목록 페이지와 상세 페이지에 데이터를 연동하는 방법에 대해 자세히 알아보겠습니다. Next.js는 React 기반의 프레임워크로, 서버 사이드 렌더링과 정적 사이트 생성을 지원하여 최적의 성능을 자랑합니다. Nest.js는 Node.js 애플리케이션을 위한 강력한 프레임워크로, 특히 RESTful API 개발에 적합합니다. 이 두 프레임워크를 결합하여 효율적인 웹 애플리케이션을 만들 수 있습니다.

1. 프로젝트 구조 설정

먼저, 두 프레임워크를 연동할 프로젝트 구조를 설정합니다. Nest.js를 백엔드 API 서버로, Next.js를 프론트엔드 웹 애플리케이션으로 사용할 것입니다.

  • 프로젝트 루트 폴더
    • nest-backend/
    • next-frontend/

1.1 Nest.js 프로젝트 생성

먼저, Nest.js 프로젝트를 생성합니다. Nest CLI를 사용하여 새로운 프로젝트를 생성하고 의존성을 설치합니다.

            
            npm install -g @nestjs/cli
            nest new nest-backend
            cd nest-backend
            npm install @nestjs/typeorm typeorm mysql2
            
            

여기서는 MySQL을 데이터베이스로 사용하였지만, 필요한 경우 다른 데이터베이스를 사용할 수도 있습니다.

1.2 Next.js 프로젝트 생성

그 다음, Next.js 프로젝트를 생성합니다. create-next-app을 사용하여 빠르게 설정할 수 있습니다.

            
            npx create-next-app next-frontend
            cd next-frontend
            npm install axios
            
            

axios는 클라이언트에서 API를 호출할 때 사용할 라이브러리입니다.

2. Nest.js API 구축

Nest.js를 사용하여 블로그 API를 구축합니다. 블로그 포스트를 다루기 위해 Post 엔티티를 생성하고, CRUD 기능을 구현합니다.

2.1 Post 엔티티 생성

Nest.js의 TypeORM을 사용하여 Post 엔티티를 생성합니다. src/posts/post.entity.ts 파일을 생성하고 다음과 같이 작성합니다:

            
            import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

            @Entity()
            export class Post {
                @PrimaryGeneratedColumn()
                id: number;

                @Column()
                title: string;

                @Column('text')
                content: string;

                @Column()
                createdAt: Date;

                @Column()
                updatedAt: Date;
            }
            
        

2.2 Posts 모듈 및 서비스 생성

Posts 모듈을 생성하고 CRUD 로직을 추가합니다. src/posts/posts.module.tssrc/posts/posts.service.ts 파일을 각각 생성합니다.

            
            import { Module } from '@nestjs/common';
            import { TypeOrmModule } from '@nestjs/typeorm';
            import { PostsController } from './posts.controller';
            import { PostsService } from './posts.service';
            import { Post } from './post.entity';

            @Module({
                imports: [TypeOrmModule.forFeature([Post])],
                controllers: [PostsController],
                providers: [PostsService],
            })
            export class PostsModule {}
            
        

2.3 Posts Controller 생성

PostsController를 생성하여 API 엔드포인트를 정의합니다. src/posts/posts.controller.ts 파일을 다음과 같이 작성합니다:

            
            import { Controller, Get, Post, Body, Param } from '@nestjs/common';
            import { PostsService } from './posts.service';
            import { Post } from './post.entity';

            @Controller('posts')
            export class PostsController {
                constructor(private readonly postsService: PostsService) {}

                @Get()
                async findAll(): Promise {
                    return this.postsService.findAll();
                }

                @Get(':id')
                async findOne(@Param('id') id: string): Promise {
                    return this.postsService.findOne(+id);
                }

                @Post()
                async create(@Body() post: Post): Promise {
                    return this.postsService.create(post);
                }
            }
            
        

2.4 Posts Service 구현하기

최종적으로, PostsService를 구현하여 데이터베이스와의 상호작용을 처리합니다. src/posts/posts.service.ts 파일을 다음과 같이 작성합니다:

            
            import { Injectable } from '@nestjs/common';
            import { InjectRepository } from '@nestjs/typeorm';
            import { Repository } from 'typeorm';
            import { Post } from './post.entity';

            @Injectable()
            export class PostsService {
                constructor(
                    @InjectRepository(Post)
                    private postsRepository: Repository,
                ) {}

                async findAll(): Promise {
                    return this.postsRepository.find();
                }

                async findOne(id: number): Promise {
                    return this.postsRepository.findOne(id);
                }

                async create(post: Post): Promise {
                    return this.postsRepository.save(post);
                }
            }
            
        

3. Next.js와 API 연동하기

이제 Next.js 애플리케이션에서 Nest.js API를 호출하여 데이터를 가져오고 페이지에 렌더링합니다. 블로그 목록 페이지와 상세 페이지를 구현해 보겠습니다.

3.1 블로그 목록 페이지 생성

블로그 목록 페이지를 생성하여 모든 포스트를 표시합니다. pages/index.js 파일을 다음과 같이 수정합니다:

            
            import { useEffect, useState } from 'react';
            import axios from 'axios';

            const Home = () => {
                const [posts, setPosts] = useState([]);

                useEffect(() => {
                    const fetchData = async () => {
                        const result = await axios('http://localhost:3000/posts');
                        setPosts(result.data);
                    };
                    fetchData();
                }, []);

                return (
                    

블로그 목록

); }; export default Home;

3.2 블로그 상세 페이지 생성

각 포스트의 상세 정보를 보여주기 위해 블로그 상세 페이지를 생성합니다. pages/post/[id].js 파일을 생성하고 다음과 같이 작성합니다:

            
            import { useRouter } from 'next/router';
            import { useEffect, useState } from 'react';
            import axios from 'axios';

            const PostDetail = () => {
                const router = useRouter();
                const { id } = router.query;
                const [post, setPost] = useState(null);

                useEffect(() => {
                    if (id) {
                        const fetchData = async () => {
                            const result = await axios(`http://localhost:3000/posts/${id}`);
                            setPost(result.data);
                        };
                        fetchData();
                    }
                }, [id]);

                if (!post) return 

Loading...

; return (

{post.title}

{post.content}

); }; export default PostDetail;

4. 결론

이번 글에서는 Next.js와 Nest.js를 연동하여 블로그 앱을 만드는 과정을 안내했습니다. Nest.js를 통해 API 서버를 구축하고, Next.js를 사용하여 클라이언트 사이드에서 데이터를 가져와서 렌더링하는 방법을 배웠습니다. 이 과정을 통해 두 프레임워크의 특성을 이해하고, 실전에 어떻게 활용할 수 있는지에 대한 통찰을 얻을 수 있었기를 바랍니다.

여기서 소개한 방법은 기본적인 예제에 불과하며, 실제 프로젝트에서는 좀 더 복잡한 상태 관리, 에러 처리, 팬던시 구현 등을 고려해야 합니다. 여러분의 프로젝트에 맞게 다양한 기능을 추가하고 발전시켜 나가십시오.

32.다국어 지원 및 로컬라이제이션, Nest.js에서 언어별 데이터 처리하기

현대 웹 애플리케이션에서 다국어 지원 및 로컬라이제이션은 매우 중요한 요소입니다. 여러 언어를 지원함으로써, 비즈니스는 더 넓은 시장을 대상으로 서비스를 제공하고, 사용자 경험을 개선할 수 있습니다. 이 글에서는 Nest.js를 사용하여 언어별 데이터 처리를 구현하는 방법에 대해 자세히 설명하겠습니다.

1. 다국어 지원의 필요성

다국어 지원은 기업이 다양한 문화적 배경을 가진 사용자에게 서비스를 제공하는 데 도움을 줍니다. 다음과 같은 이유로 다국어 지원이 필요합니다:

  • 글로벌 시장 접근성: 다국적 기업들이 자신의 서비스를 다양한 언어로 제공함으로써, 전 세계의 사용자들에게 접근할 수 있습니다.
  • 사용자 경험 향상: 사용자가 익숙한 언어로 서비스를 사용할 수 있어, 더 나은 사용자 경험을 제공합니다.
  • 문화적 민감성: 언어 지원은 다양한 문화적 특성과 사용자의 기대를 이해하고 대응할 수 있는 방법 중 하나입니다.

2. Nest.js 소개

Nest.js는 최신 JavaScript 및 TypeScript를 사용하여 구축된 서버 측 애플리케이션 프레임워크입니다. 강력한 타입 지원과 모듈화된 구조로 구성되어 있어, 유지보수하기 쉽고 확장성이 뛰어난 애플리케이션을 개발할 수 있습니다. Nest.js는 Express 또는 Fastify를 기반으로 하며, 이를 통해 고성능 웹 애플리케이션을 구성할 수 있습니다.

3. Nest.js에서 다국어 지원 구현하기

3.1. 필요 라이브러리 설치

다국어 처리를 위해 i18n 라이브러리를 사용할 것입니다. 다음 명령어로 설치할 수 있습니다:

npm install i18n

3.2. i18n 설정하기

Nest.js 애플리케이션에서 i18n을 설정하려면, 먼저 생성한 애플리케이션의 메인 파일인 main.ts에 다음과 같이 코드를 추가합니다.

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as i18n from 'i18n'; 

async function bootstrap() {
    i18n.configure({
        locales: ['en', 'ko', 'ja'], // 지원할 언어 목록
        directory: __dirname + '/locales', // 번역 파일이 위치할 디렉토리
        defaultLocale: 'ko', // 기본 언어
        autoReload: true, // 코드 변경 시 리로딩 여부
        syncFiles: true // 동기화 여부
    });

    const app = await NestFactory.create(AppModule);
    app.use(i18n.init); // i18n 초기화
    await app.listen(3000);
}
bootstrap();

3.3. 언어별 데이터 준비

각 언어에 대한 번역 문자열을 별도의 JSON 파일로 생성합니다. locales 디렉토리를 생성하고 그 안에 en.json, ko.json, ja.json 파일을 만듭니다. 예를 들어:

// locales/ko.json
{
    "greeting": "안녕하세요",
    "farewell": "안녕히 가세요"
}
// locales/en.json
{
    "greeting": "Hello",
    "farewell": "Goodbye"
}
// locales/ja.json
{
    "greeting": "こんにちは",
    "farewell": "さようなら"
}

3.4. 언어 결정 및 사용하기

클라이언트가 요청한 언어에 따라 적절한 번역을 사용하기 위해, 요청 헤더나 쿼리 매개변수를 통해 언어를 결정할 수 있습니다. 다음과 같이 컨트롤러를 작성하여 다국어 지원을 구현할 수 있습니다:

import { Controller, Get, Req } from '@nestjs/common';
import { Request } from 'express';

@Controller('greet')
export class GreetController {
    @Get()
    getGreeting(@Req() req: Request): string {
        return req.__('greeting'); // 요청에 따른 인사말 반환
    }
}

4. 클라이언트에서 언어 선택하기

클라이언트 측에서는 사용자가 선호하는 언어를 선택할 수 있는 인터페이스를 제공합니다. 예를 들어, Next.js 프레임워크를 사용하여 사용자가 선택한 언어에 따라 요청을 보낼 수 있습니다.

4.1. Next.js 클라이언트 작성하기

Next.js에서 페이지를 생성하고 언어 선택 버튼을 만든 후, 사용자가 언어를 변경할 수 있도록 로직을 구현합니다. 아래는 언어 선택 버튼이 포함된 간단한 페이지 예제입니다:

import { useState } from 'react';

const LanguageSelector = () => {
    const [language, setLanguage] = useState('ko');

    const changeLanguage = (lang) => {
        setLanguage(lang);
        // 서버 요청 보내기
        fetch(`http://localhost:3000/greet?lang=${lang}`)
            .then(response => response.text())
            .then(data => alert(data));
    }

    return (
        

언어 선택

); }; export default LanguageSelector;

5. 결론

Nest.js를 사용하여 다국어 지원 및 로컬라이제이션 기능을 구현하는 과정은 복잡할 수도 있으나, 필요한 도구와 설정을 통해 쉽게 할 수 있습니다. 위의 내용에서는 i18n 라이브러리를 통해 다양한 언어를 지원하는 방법과 클라이언트에서 언어를 선택할 수 있는 간단한 인터페이스를 구현하는 방법을 설명했습니다. 이를 통해 사용자 경험을 향상시키고 글로벌 시장에 접근하는 데 도움이 되는 웹 애플리케이션을 개발할 수 있습니다.

앞으로 더 많은 기능과 사용자 친화적인 인터페이스를 추가하여, 다국어 지원을 더욱 강화할 수 있습니다. 독자 여러분의 프로젝트에도 다국어 지원을 성공적으로 적용하시길 바랍니다!

4.Next.js와 Nest.js 기본 프로젝트 구조 만들기, Next.js와 Nest.js 기본 폴더 구조 이해

이번 포스트에서는 Next.jsNest.js를 이용하여 기본 프로젝트 구조를 만드는 방법에 대해 자세히 알아보겠습니다. JavaScript와 TypeScript를 사용하는 프레임워크인 이들 두 가지는 웹 개발에서 인기가 높습니다. Next.js는 React 기반의 프레임워크로, 탁월한 SSR(Server-Side Rendering)과 정적 페이지 생성을 지원하며, Nest.js는 Angular에서 영감을 받아 집약된 구조로 웹 애플리케이션을 구축하는 강력한 서버 사이드 프레임워크입니다. 이 두 가지 프레임워크를 결합하여 전체 스택 애플리케이션을 구축할 때 고려해야 할 기본적인 폴더 구조에 대해 알아보겠습니다.

1. 프로젝트 생성

먼저 Next.js와 Nest.js 프로젝트를 생성합니다. 각 프레임워크별로 CLI(Command Line Interface)를 통해 쉽게 프로젝트를 설정할 수 있습니다.

1.1 Next.js 프로젝트 생성

npx create-next-app@latest my-next-app

위의 명령어를 실행하면 my-next-app이라는 이름의 새 Next.js 프로젝트가 생성됩니다. 생성된 폴더로 이동합니다.

cd my-next-app

1.2 Nest.js 프로젝트 생성

npm i -g @nestjs/cli

위의 명령어로 Nest CLI를 설치한 후, 아래와 같이 새로운 Nest.js 프로젝트를 생성합니다.

nest new my-nest-app

생성된 폴더로 이동합니다.

cd my-nest-app

2. 기본 폴더 구조 이해

각 프레임워크의 기본 폴더 구조를 알아보겠습니다. 특정한 폴더 구조는 프로젝트의 유지 관리 및 확장성을 높이는 데 도움이 됩니다.

2.1 Next.js 기본 폴더 구조

Next.js 프로젝트의 기본 구조는 다음과 같습니다:


my-next-app/
├── node_modules/
├── public/
│   ├── favicon.ico
│   ├── vercel.svg
├── styles/
│   ├── globals.css
│   └── Home.module.css
├── pages/
│   ├── api/
│   ├── _app.js
│   ├── index.js
└── package.json
  • node_modules: 프로젝트에서 사용하는 모든 의존성이 설치되는 디렉토리입니다.
  • public: 정적 파일을 저장하는 곳으로, 예를 들어 이미지나 글꼴을 저장합니다.
  • styles: CSS 파일을 저장하는 폴더로, 각 컴포넌트에 대한 스타일을 정의할 수 있습니다.
  • pages: Next.js의 라우팅을 담당하는 폴더로, api 폴더 안에는 API 라우트가 포함됩니다. 또한 _app.js는 애플리케이션의 레이아웃을 정의하는 데 사용됩니다.
  • package.json: 프로젝트의 메타데이터 및 스크립트, 의존성을 정의하는 파일입니다.

2.2 Nest.js 기본 폴더 구조

Nest.js 프로젝트의 기본 구조는 다음과 같습니다:


my-nest-app/
├── src/
│   ├── app.module.ts
│   ├── app.controller.ts
│   ├── app.service.ts
└── package.json
  • src: 애플리케이션의 소스 코드가 포함되는 폴더입니다. 기본적으로 app.module.ts, app.controller.ts, app.service.ts 파일이 생성됩니다.
  • app.module.ts: 루트 모듈로, 애플리케이션의 구성 요소를 가져오고 종합합니다.
  • app.controller.ts: 클라이언트의 요청을 처리하는 컨트롤러입니다.
  • app.service.ts: 비즈니스 로직을 구현하는 서비스입니다.
  • package.json: 의존성 관리 및 빌드 스크립트가 포함됩니다.

3. Next.js와 Nest.js 연결하기

Next.js와 Nest.js를 모두 설치한 후, 이 두 가지를 연결하여 전체 스택 애플리케이션을 만드는 과정에 대해 설명하겠습니다.

3.1 Nest.js API 개발

우선 Nest.js를 사용하여 API를 개발합니다. 여기에 간단한 사용자 정보를 관리하는 API를 만들어 보겠습니다. app.controller.ts 파일을 다음과 같이 수정하겠습니다.


import { Controller, Get } from '@nestjs/common';

@Controller('users')
export class AppController {
    @Get()
    findAll(): string {
        return '사용자 리스트';
    }
}

3.2 Next.js에서 API 사용하기

이제 Next.js에서 위에서 만든 Nest.js API를 호출해봅시다. pages/index.js 파일을 다음과 같이 수정합니다.


import { useEffect, useState } from 'react';

export default function Home() {
    const [users, setUsers] = useState([]);

    useEffect(() => {
        fetch('/api/users')
            .then((response) => response.json())
            .then((data) => setUsers(data));
    }, []);

    return (
        

사용자 리스트

    {users.map((user) => (
  • {user.name}
  • ))}
); }

4. 결론

Next.js와 Nest.js의 기본 프로젝트 구조 및 폴더 구조에 대해 알아보았습니다. 이러한 구조는 애플리케이션의 유지 관리를 더 쉽게 만들고, 개발자들이 더 나은 협업을 할 수 있도록 도와줍니다. 또한, 이번 포스트는 Next.js와 Nest.js를 연동하여 API를 호출하는 방법도 간단히 보여 주었습니다. 이 두 기술 스택을 이용해 다양한 웹 애플리케이션을 개발할 수 있으니, 앞으로 더 많은 기능을 추가해 보세요. 감사합니다!

42.Nest.js와 Next.js에서 웹소켓 활용하기, Nest.js에서 실시간 통신 구현하기

이번 강좌에서는 Nest.js와 Next.js를 활용하여 실시간 통신을 구현하는 방법에 대해 설명하겠습니다. 웹소켓(WebSocket)은 클라이언트와 서버 간의 양방향 통신을 가능하게 하는 프로토콜입니다. 이를 통해 정보를 실시간으로 주고 받을 수 있으며, 특히 채팅 애플리케이션, 실시간 대시보드 등과 같은 응용 프로그램에서 유용합니다.

1. 웹소켓의 기초 이해

웹소켓은 HTTP 기반의 통신 채널로, 매번 연결을 새로 여는 대신에 한 번 연결된 이후로 지속적인 연결을 유지하여 양방향 통신을 가능하게 합니다. 이로 인해 클라이언트와 서버 간의 데이터 전송 속도가 빨라지고, 불필요한 오버헤드가 줄어드는 장점이 있습니다.

1.1 웹소켓의 동작 구조

1. 클라이언트가 WebSocket 서버에 연결 요청.
2. 서버는 요청을 수락하여 연결을 완성.
3. 클라이언트와 서버가 연결된 후 양방향으로 데이터 전송.
4. 클라이언트 또는 서버가 연결을 종료.

2. Nest.js에서 웹소켓 구현하기

Nest.js는 Node.js를 위한 프레임워크로, 웹소켓을 쉽게 구현할 수 있도록 도와주는 ‘socket.io’ 패키지를 지원합니다. 먼저 Nest.js 프로젝트를 생성하고 필요한 패키지를 설치하는 방법을 알아보겠습니다.

2.1 Nest.js 프로젝트 생성

npm install -g @nestjs/cli
nest new websocket-demo
cd websocket-demo

2.2 필요한 패키지 설치

웹소켓 기능을 사용하기 위해 socket.io와 관련 패키지를 설치합니다:

npm install --save @nestjs/platform-socket.io socket.io

2.3 웹소켓 모듈 생성

웹소켓을 구현하기 위해 새로운 모듈과 서비스를 생성합니다:

nest g module chat
nest g service chat
nest g gateway chat

2.4 웹소켓 게이트웨이 구현

생성된 chat.gateway.ts 파일을 다음과 같이 수정하여 웹소켓 기능을 구현합니다:

import { WebSocketGateway, WebSocketServer, SubscribeMessage, WebSocketIconService } from '@nestjs/websockets';
import { Server } from 'socket.io';

@WebSocketGateway()
export class ChatGateway {
  @WebSocketServer() server: Server;

  @SubscribeMessage('message')
  handleMessage(client: any, payload: { sender: string; content: string }): void {
    this.server.emit('message', payload);
  }
}

2.5 서비스에 로직 추가

chat.service.ts에 비즈니스 로직을 추가하여 더 복잡한 기능을 구현할 수 있습니다. 예를 들어, 사용자 목록 관리, 메시지 저장 등을 추가할 수 있습니다.

3. Next.js에서 웹소켓 클라이언트 구현하기

Next.js에서는 브라우저에서 웹소켓 서버와 통신하는 클라이언트를 쉽게 생성할 수 있습니다. socket.io-client 패키지를 사용하면 기존의 socket.io 서버와 쉽게 연결할 수 있습니다.

3.1 Next.js 프로젝트 생성

npx create-next-app websocket-client
cd websocket-client
npm install socket.io-client

3.2 웹소켓 클라이언트 구현

Next.js의 pages/index.tsx 파일을 수정하여 웹소켓 연결을 구현합니다:

import { useEffect, useState } from 'react';
import { io } from 'socket.io-client';

const socket = io('http://localhost:3000'); // Nest.js 서버의 주소

export default function Home() {
  const [messages, setMessages] = useState([]);
  const [input, setInput] = useState('');

  useEffect(() => {
    socket.on('message', (message) => {
      setMessages((prev) => [...prev, message]);
    });

    return () => {
      socket.off('message');
    };
  }, []);

  const sendMessage = () => {
    socket.emit('message', { sender: 'User', content: input });
    setInput('');
  };

  return (
    

WebSocket Chat

{messages.map((msg, index) => (
{msg.sender}: {msg.content}
))}
setInput(e.target.value)} placeholder="Type a message" />
); }

4. Nest.js와 Next.js 연결하기

Nest.js 서버를 실행하고 Next.js 클라이언트를 통해 연결하면, 클라이언트가 Nest.js 서버와 실시간으로 메시지를 주고받을 수 있습니다. 이를 통해 간단한 채팅 애플리케이션을 구현할 수 있습니다.

4.1 Nest.js 서버 실행

npm run start

4.2 Next.js 클라이언트 실행

npm run dev

브라우저에서 http://localhost:3000에 접속하면 웹소켓 클라이언트가 실행되고, 다른 브라우저에서 같은 주소로 접속하여 메시지를 주고받는 실시간 통신이 가능해집니다.

5. 결론

Nest.js와 Next.js를 활용하여 간단한 웹소켓 기반의 실시간 통신 애플리케이션을 만들 수 있었습니다. 웹소켓은 실시간 데이터를 전달하는데 매우 유용하며, 다양한 분야에서 활용될 수 있습니다. 본 강좌를 통해 여러분이 웹소켓의 기초를 이해하고, Nest.js와 Next.js에서 쉽게 구현할 수 있는 방법을 배울 수 있었기를 바랍니다.

6. 추가적인 학습 자료

9.Next.js에서 동적 라우팅 및 페이지 생성하기, 블로그 게시글 상세 페이지 동적 생성하기

최근 웹 애플리케이션 개발에서 Next.js의 인기가 급증하고 있습니다. Next.js는 React 기반의 프레임워크로, 서버 사이드 렌더링(SSR) 및 정적 사이트 생성(SSG) 기능을 제공하여 SEO와 성능을 최적화할 수 있도록 도와줍니다. 이 글에서는 Next.js의 동적 라우팅과 페이지 생성에 대해 깊이 있게 살펴보겠습니다. 특히, 블로그 게시글의 상세 페이지를 동적으로 생성하는 방법을 중점적으로 다룰 것입니다.

1. 동적 라우팅(Dynamic Routing) 이해하기

Next.js의 라우팅은 파일 시스템 기반입니다. 이 말은 페이지를 생성하기 위해 파일 및 디렉토리 구조를 따르는 것을 의미합니다. Next.js에서 동적 라우팅을 구현하려면, 파일명에 대괄호([])를 사용하여 동적인 부분을 표시할 수 있습니다.

1.1 동적 페이지 생성

예를 들어, 블로그 게시글에 대한 상세 페이지를 만들고자 할 때, 각 게시글의 ID나 슬러그를 기반으로 URL을 동적으로 생성할 수 있습니다. 동적 경로를 생성하기 위해, pages 디렉토리 내에 다음과 같은 파일을 생성합니다:

pages/posts/[id].js

1.2 페이지 컴포넌트 작성하기

이제 [id].js 파일에서 동적 페이지 컴포넌트를 작성하겠습니다. 먼저, Next.js에서 제공하는 useRouter 훅을 사용하여 URL 파라미터에 접근하고, 게시글 데이터를 가져오는 함수를 작성합니다.