๋ด๋ณด๋ด๋ฒ(๋ด๊ฐ ๋ณด๋ ค๊ณ ๋ด๊ฐ ๋ฒ์ญํ...) ์ํฐํด
โป ์์ด ์ ๊ณต์๋ ํด์ธ ์ ํํ๋ ์๋๊ธฐ์ ๋ฒ์ญ์๋ ์์ญ, ์ค์ญ, ๊ตฌ๊ธ ๋ฒ์ญ์ด ๋ฌด์ํ ๋ง์ ์ ์์ผ๋ฉฐ, ๊ฐ์ธ์ ์ธ ๊ณต๋ถ ๋ชฉ์ ์ผ๋ก ๋ฒ์ญํ๋ค ๋ณด๋ ์คํ๋ ๋ง์ ์ ์๋ค. ์ ํํ ๋ด์ฉ์ ํด๋น ์ํฐํด์ ์ง์ ์ดํด๋ณด๊ฑฐ๋ ๋ค๋ฅธ ์ ๋ณด๋ค์ ๋ ์ฐพ์๋ณด๋ ๊ฒ์ ์ถ์ฒํ๋ค.
(ํ์ง๋ง ๋๊ธ ํผ๋๋ฐฑ๋ ํ์ํฉ๋๋ค๐ ๊ธ์ ์ฝ์ด๋ณด์๊ณ ๋์์ ์ป์ผ์ จ๋ค๋ฉด ์ํฐํด ์ ์์ ๋ธ๋ก๊ทธ์์ ์ข์์๋ ๋๋ฌ์ฃผ์ธ์.)
Understanding Next.js Data Fetching (CSR, SSR, SSG, ISR) by Theodorus Clarence ์๋ฌธ ์ฝ๊ธฐ >>
๐ ์ด ์ํฐํด์ ๋ฒ์ญํ๊ฒ ๋ ์ด์
์ฌ์ด๋ ํ๋ก์ ํธ๋ฅผ ์งํํ๋ฉด์ ๋ด๊ฐ ์์ฒด์ ์ผ๋ก ๋ง๋ API๊ฐ ์๊ณ ๊ทธ API์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์์ ์ฌ์ฉ์์๊ฒ ๋ณด์ฌ์ฃผ์ด์ผ ํ๋ ํ๋ฉด์ด ์์๋ค. ๋งค๋ฒ ๋ฐ์ดํฐ๊ฐ ๋์ผํ๊ฒ ๋ณด์ฌ์ง๋ฉด ์ฌ๋ฏธ๊ฐ ์์ผ๋ ๋ค์ด์ฌ ๋๋ง๋ค ๋น ๋ฅด๊ฒ ๋ก๋๊ฐ ๋๋ฉด์๋ ๋๋คํ๊ฒ ๋ณด์ฌ์ง๊ธฐ๋ฅผ ์ํ๊ณ ํฌ๋กฌ Lighthouse์ ์ ์๋ ์ด๋ป๊ฒ๋ ๋์ฌ๋ณด๋ ค๊ณ ํ์์ด ๋์ด์์๋ค. ๊ทธ๋์ Next.js Data Fetching ๋ฌธ์๋ฅผ ๋ณด๋ฉฐ ์ด๊ฒ์ ๊ฒ ์๋ํด๋ดค๋ ๊ธฐ์ต์ด ๋๋ค. ๋ช ํํ๊ฒ SSR, SSG, ISR์ ์ดํดํ์ง ๋ชปํ ์ํ์์ ๊ดํ revalidate๋ฅผ ์ถ๊ฐํด์ ์ซ์๋ ๋ฐ๊ฟ๋ณด๊ณ ๋ค๋ฅธ ์ต์ ๋ ๋ฃ์ด๋ณด๊ณ ๊ทธ๋ฌ์๋๋ฐ... ์ฐ์ ๋ฌธ์ ๋ ํด๊ฒฐํ๊ณ ๋ ๋ค ํ์ฐธ ๋ค์ ์ ๋๋ก ์ง๊ณ ๋์ด๊ฐ๋ฉด ์ข์ง์์๊น ํ๋ ์๊ฐ์ ์ฌ๋ฌ ์ํฐํด์ ๋ค์ ธ๋ดค๋ค. ๊ทธ๋ฌ๋ค ๋์ ๋ ์ํฐํด์ด ํ์ฌ ๋ฒ์ญํ๋ ค๊ณ ํ๋ ์ํฐํด์ด๋ค. ์ด์ง ํ์ด๋ง ๋ดค์ ๋๋ถํฐ ์ค! ๊ต์ฅํ ์ ์ ๋ฆฌ๋ ๋๋์ด๋ค! ์ถ์์ง๋ง ๊ฐ์ก๊ณ ์ฝ์ด์ผํ๋ค๋ ์๊ฐ์ ํ๋๋ฌ ๋ฏธ๋ค๋์๋ค ์ด์ ์ผ ๋ฒ์ญํด๋ณธ๋ค.
Introduction
When I started to learn Next.js, I got overwhelmed with the list of abbreviations that looks similar, I didn't know what it is and what is the difference. It is quite confusing because when using Create React App, we usually only use 1 strategy to fetch data from API which is using useEffect.
๋ด๊ฐ ์ฒ์์ผ๋ก Next.js๋ฅผ ๋ฐฐ์ฐ๊ธฐ ์์ํ์ ๋ ๋ญ๊ฐ ๋น์ทํด๋ณด์ด๋ ์ฝ์ด๋ค์ ๋ชฉ๋ก์ ๋ณด๊ณ ๋นํฉ์ค๋ฌ์ ๋ค. ๊ทธ๊ฒ ๋ญ์ง๋ ๋ชจ๋ฅด๊ณ ์ฐจ์ด์ ๋ ๋ชฐ๋์๋ค. ๊ฝค ํท๊ฐ๋ ธ๋๋ฐ Create React App์ ์ฌ์ฉํ ๋ ๋๊ฐ ํ ๊ฐ์ง ์ ๋ต, useEffect๋ฅผ ์ฌ์ฉํ์ฌ API๋ก๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๊ธฐ ๋๋ฌธ์ด๋ค.
Next.js has many data fetching strategies. Although initially Next.js was well known to be a Server-Side Rendering Framework, it turns out that Next.js has 4 methods of Data Fetching. Here is the short explanation each so you get familiar with the abbreviation of CSR, SSR, SSG, ISR.
Next.js๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๋ ์ฌ๋ฌ ์ ๋ ฅ๋ค์ด ์๋ค. Next.js๊ฐ ์ฒ์์๋ ์๋ฒ ์ฌ์ด๋ ๋ ๋๋ง ํ๋ ์์ํฌ๋ก ์ ์๋ ค์ง๊ธด ํ์ง๋ง, Next.js๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๋ 4๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๊ฒ ๋์๋ค. ์ด์ ์ฌ๋ฌ๋ถ์ด CSR, SSR, SSG, ISR์ด๋ผ๋ ์ฝ์ด์ ์ต์ํด์ง๋๋ก ์งง๊ฒ ์ค๋ช ์ ์งํํ๊ฒ ๋ค.
- CSR - Client-Side Rendering, this is the usual kind of data fetching using useEffect, it will fetch the data from the API every single page request on the client-side (after the page is rendered, then the function will run).
- SSR - Server-Side Rendering, will run a special function to fetch data from API every page request on the server-side (before the page is loaded, that special function will run first, creating a delay, then after that, it will serve the page).
- SSG - Static Site Generation, will run a special function to fetch data once when that page builds.
- ISR – Incremental Static Regeneration, this is a new thing, shortly put, a combination of SSG, and SSR, where it served statically, but at a certain time and certain condition that page will rebuild and fetch the data from the API again.
- CSR - Client-Side Rendering, ์ด๊ฒ์ useEffect๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๋ ๊ฒ๊ณผ ๊ฐ์ ์ข ๋ฅ์ ๋ฐฉ๋ฒ์ผ๋ก, ํด๋ผ์ด์ธํธ ์ธก์์ ๋งค ์ฑ๊ธ ํ์ด์ง ์์ฒญ๋ง๋ค API๋ก๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์จ๋ค. (ํ์ด์ง๊ฐ ๋ ๋๋๊ณ ๋ ํ, ํจ์๊ฐ ๋์ํ๋ค.)
- SSR - Server-Side Rendering, ์๋ฒ ์ธก์์ ๋งค ํ์ด์ง ํธ์ถ๋ง๋ค ํน๋ณํ ํจ์๋ฅผ ๋์์์ผ API๋ก๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์จ๋ค. (ํ์ด์ง๊ฐ ๋ก๋๋๊ธฐ ์ ์, ๊ทธ ํน๋ณํ ํจ์๊ฐ ๋จผ์ ๋์ํ๊ณ ๋๋ ์ด๋ฅผ ๋ง๋ค๊ณ ๊ทธ ํ์ ํ์ด์ง๋ฅผ ๊ฐ์ ธ์จ๋ค.)
- SSG - Static Site Generation, ํ์ด์ง๊ฐ ๋น๋๋ ๋ ํน๋ณํ ํจ์๋ฅผ ๋์์์ผ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์จ๋ค.
- ISR - Incremental Static Regeneration, ์๋ก์ด ๋ฐฉ๋ฒ์ธ๋ฐ ์งง๊ฒ ์ค๋ช ํ์๋ฉด SSG์ SSR์ ๊ฒฐํฉ์ผ๋ก ์ ์ ์ผ๋ก ์ ๊ณตํ๋ ๊ณณ์์ ํน์ ์๊ฐ๊ณผ ํน์ ์กฐ๊ฑด์ ํด๋น ํ์ด์ง๊ฐ ์ฌ๋น๋๋๊ณ API์์ ๋ฐ์ดํฐ๋ฅผ ๋ค์ ๊ฐ์ ธ์จ๋ค.
Don't worry if you didn't get that, because I will be explaining it thoroughly, just familiarize the words first.
์ฒ ์ ํ ์ค๋ช ์ ํด์คํ ๋ ์ดํด๊ฐ ์๋๋คํด๋ ๊ฑฑ์ ๋ง๋ผ, ๋จผ์ ๋จ์ด์ ์ต์ํด์ง๋๋ก ํ์.
I mentioned before that there is a special function that will run when using a specific data fetching method. Keep that in mind as I will show you what is that special function.
์์ ์ธ๊ธํ๋ ๊ฒ์ฒ๋ผ ํน์ ๋ฐ์ดํฐ ๊ฐ์ ธ์ค๊ธฐ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ๋ ๋์ํ๋ ํน๋ณํ ํจ์๊ฐ ์๋ค. ๊ทธ ํน๋ณํ ํจ์๊ฐ ๋ฌด์์ธ์ง ๋ณด์ฌ์คํ ๋ ์ฐธ๊ณ ํ๋ผ.
This code example will fetch a date-time from an API using axios, then render it on the page. It is useful to see the date-time so we can truly know when the API is hit.
์ฌ๊ธฐ์ ์ฝ๋ ์์๋ axios๋ฅผ ์ฌ์ฉํด์ API๋ก๋ถํฐ ๋ ์ง์ ์๊ฐ์ ๊ฐ์ ธ์ค๊ณ ํ์ด์ง์ ๋ ๋ํ๋ค. ๋ ์ง์ ์๊ฐ์ ๋ณด๋ ๊ฒ์ด ์ ์ฉํ ๊ฒ์ API์ ์ธ์ ์ ๊ทผ๋๋์ง ์ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
Client-Side Rendering (CSR)
Special Function: `useEffect`
Code Example
export default function CSRPage() {
const [dateTime, setDateTime] = React.useState<string>();
React.useEffect(() => {
axios
.get('https://worldtimeapi.org/api/ip')
.then((res) => {
setDateTime(res.data.datetime);
})
.catch((error) => console.error(error));
}, []);
return (
<main>
<TimeSection dateTime={dateTime} />
</main>
);
}
Demo
Terms:
- PT → Preview Time, the time shown when the API is hit. Can be seen in the middle.
- RT → Real-Time, the real ticking time updating every second, can be seen on the right bottom corner
- PT → ๋ฏธ๋ฆฌ๋ณด๊ธฐ ์๊ฐ, API์ ์ ๊ทผํ์ ๋์ ์๊ฐ. ์ค๊ฐ์ ๋ณด์ฌ์ง.
- RT → ์ค์ ์๊ฐ, ๋งค์ด ์ ๋ฐ์ดํธ๋๋ ์ค์ ์๊ฐ์ผ๋ก ์ฐ์ธก ํ๋จ ์ฝ๋์ ๋ณด์ฌ์ง.
Video Description:
- Page reloads on 15:46:03 Real-Time (RT), then a LOADING indicator is shown
- After about 1s, Preview Time is showing 15:46:04(PT)
- 15:46:03 ์ค์ ์๊ฐ(RT)์ ํ์ด์ง๊ฐ ์ฌ๋ก๋๋๊ณ LOADING ํ์๊ฐ ๋ณด์ฌ์ง
- 1์ด ์ฏค ํ์ ๋ฏธ๋ฆฌ๋ณด๊ธฐ ์๊ฐ 15:46:04(PT)๊ฐ ๋ณด์ฌ์ง
Keys to Emphasize
- useEffect function, this function is the key indicator that a page is using Client-Side Rendering.
- LOADING indicator, because the data fetching runs after the page is rendered, the data is not fetched instantly, therefore showing a loading state.
- Data is fetched on every page request, which is why the time shown is different for each reloads.
- useEffect ํจ์, ์ด ํจ์๋ ํ์ด์ง๊ฐ Client-Side Rending์ ์ฌ์ฉํ๊ณ ์๋ค๋ ํต์ฌ ์์์ด๋ค.
- LOADING ํ์, ๋ฐ์ดํฐ ๊ฐ์ ธ์ค๊ธฐ๊ฐ ํ์ด์ง๊ฐ ๋ ๋๋ ํ ์คํ๋๊ธฐ ๋๋ฌธ์, ๋ฐ์ดํฐ๋ ์ฆ์ ํจ์นญ๋๋ ๊ฒ์ด ์๋๊ณ ๋ฐ๋ผ์ ๋ก๋ฉ ์ํ๊ฐ ๋ณด์ฌ์ง๋ค.
- ๋ฐ์ดํฐ๋ ๋งค ํ์ด์ง ์์ฒญ๋ง๋ค ํจ์น๋๋ค, ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๊ฐ ์ฌ๋ก๋ ๋ง๋ค ๋ค๋ฅธ ์๊ฐ์ด ๋ณด์ฌ์ง๋ค.
Server Side Rendering (SSR)
Special Function: `getServerSideProps`
Code Example
export default function SSRPage({ dateTime }: SSRPageProps) {
return (
<main>
<TimeSection dateTime={dateTime} />
</main>
);
}
export const getServerSideProps: GetServerSideProps = async () => {
const res = await axios.get('https://worldtimeapi.org/api/ip');
return {
props: { dateTime: res.data.datetime },
};
};
Demo
Video Description:
- Clicked the link on 16:32:38(RT), a slight pause for 2s, then page loads showing 16:02:40(PT)
- 16:02:38(RT)*์ ๋งํฌ๋ฅผ ํด๋ฆญํ๊ณ , ์ฝ 2์ด ์ ๋์ ๋ฉ์ถค ํ์, 16:02:40(PT) ๋ณด์ด๋ ํ์ด์ง๊ฐ ๋ก๋๋๋ค.
(* ์๋ฌธ์ 16:32:38์ด ์คํ์ธ ๊ฒ ๊ฐ์์ ๋ฒ์ญ์ 16:02:38๋ก ์์ ํจ.)
Keys to Emphasize
- getServerSideProps function, this function is the key indicator that a page is using Server-Side Rendering.
- DELAY before render, and no LOADING indicator, the data is fetched before the page is rendered, so there will be a slight delay where the API is being hit at the moment, then it will show the page without loading indicator
- Data is fetched on every page request, which is why the time shown is different for each reloads.
- getServerSideProps ํจ์, ์ด ํจ์๋ ํ์ด์ง๊ฐ Server-Side Rending์ ์ฌ์ฉํ๋ค๋ ํต์ฌ ์์์ด๋ค.
- ๋ ๋ ์ ๋๋ ์ด, ๊ทธ๋ฆฌ๊ณ LOADING ํ์๊ฐ ์์, ๋ฐ์ดํฐ๋ ํ์ด์ง๊ฐ ๋ ๋๋๊ธฐ ์ ์ ํจ์น๋๊ณ ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ API๊ฐ ์ ๊ทผํ๋ ์๊ฐ์ ์ฝ๊ฐ ๋๋ ์ด๊ฐ ๋ฐ์ํ ํ์ ๋ก๋ฉ ํ์ ์์ด ํ์ด์ง์ ๋ณด์ฌ์ง๋ค.
- ๋ฐ์ดํฐ๋ ๋งค ํ์ด์น ์์ฒญ๋ง๋ค ํจ์น๋๋ค, ์ด๊ฒ์ด ๊ฐ ์ฌ๋ก๋ ๋ง๋ค ๋ค๋ฅธ ์๊ฐ์ด ๋ณด์ฌ์ง๋ ์ด์ ์ด๋ค.
CSR vs SSR
Here is the difference between CSR vs SSR, keep an eye on delay and loading indicators.
์ด์ CSR๊ณผ SSR ์ฌ์ด์ ์ฐจ์ด์ ์ ๋ํด ์ด์ผ๊ธฐํ๋ ๋๋ ์ด์ ๋ก๋ฉ ํ์์ ์ฃผ์ํด๋ณด์.
Video Description:
- When clicking CSR, with no delay a LOADING text is visible for a second, then the Preview Time loads.
- When clicking SSR, a slight delay happened, then the page loads.
- CSR์ ํด๋ฆญํ๋ฉด ๋๋ ์ด ์์ด LOADING ํ ์คํธ๊ฐ ์ ๊น ๋ณด์ฌ์ง๊ณ Preview ์๊ฐ์ด ๋ก๋๋๋ค.
- SSR์ ํด๋ฆญํ๋ฉด ์ฝ๊ฐ์ ๋๋ ์ด ํ์ ํ์ด์ง๊ฐ ๋ก๋๋๋ค.
Keys to Emphasize
- CSR hit the API after the page loads.
- SSR hit the API before the page loads.
- CSR์ ํ์ด์ง ๋ก๋ ํ์ API์ ์ ๊ทผํ๋ค.
- SSR์ ํ์ด์ง ๋ก๋ ์ ์ API์ ์ ๊ทผํ๋ค.
Short addition
I will probably create a new post about the pros and cons of each method, but when using CSR the SEO is not really great because the data is only fetched after the page renders. This is useful and convenient when we are creating a page with a gated authentication, as you don't really need SEO for pages like the dashboard, edit profile page, etc.
์๋ง๋ ๊ฐ ๋ฉ์๋์ ์ฅ๋จ์ ์ ๋ํด ์๋ก์ด ํฌ์คํธ๋ฅผ ์์ฑํ ๊ฒ์ด๊ธด ํ์ง๋ง CSR์ ์ฌ์ฉํ ๋ SEO์๋ ๊ทธ๋ค์ง ์ข์ง ์๋๋ฐ ์๋ํ๋ฉด ๋ฐ์ดํฐ๊ฐ ํ์ด์ง๊ฐ ๋ ๋๋ ํ์๋ง ๊ฐ์ ธ์์ง๊ธฐ ๋๋ฌธ์ด๋ค. ์ด ๋ฐฉ๋ฒ์ ๋์๋ณด๋๋ ํ๋กํ ์์ ํ์ด์ง์ ๊ฐ์ SEO๊ฐ ๋ณ๋ก ํ์๊ฐ ์๋ ๊ฒ์ดํธ ์ธ์ฆ์ด ์๋ ํ์ด์ง๋ฅผ ์์ฑํ ๋ ์ ์ฉํ๊ณ ํธ๋ฆฌํ๋ค.
But, for the SSR, although it creates a delay, data that was fetched is injected and helps SEO. This is quite useful for a thread or post that we need to get traffic into, like Reddit or some sort.
ํ์ง๋ง SSR์ ๋ํด์๋ ๋๋ ์ด๊ฐ ์๊ธฐ๋ ํ์ง๋ง ๊ฐ์ ธ์จ ๋ฐ์ดํฐ๊ฐ ์ฃผ์ ๋์๊ณ SEO์๋ ๋์์ด ๋๋ค. ์ด ๋ฐฉ๋ฒ์ Reddit์ด๋ ๊ทธ์ ๋น์ทํ ์ข ๋ฅ์ ํธ๋ํฝ์ ๊ฐ์ ธ์์ผํ๋ ์ค๋ ๋๋ ํฌ์คํธ์ ์ ์ฉํ๋ค.
Static Site Generation (SSG)
Special function: `getStaticProps`
Code Example
export default function SSGPage({ dateTime }: SSGPageProps) {
return (
<main>
<TimeSection dateTime={dateTime} />
</main>
);
}
export const getStaticProps: GetStaticProps = async () => {
const res = await axios.get('https://worldtimeapi.org/api/ip');
return {
props: { dateTime: res.data.datetime },
};
};
Demo
Video Description:
- Preview Time is showing 13:39:36(PT). But the real-time is 16:16:59(RT), about 3 hours late.
- Reloading and going back and forth to the home page did not change anything.
- ๋ฏธ๋ฆฌ๋ณด๊ธฐ ์๊ฐ์ 13:39:36(PT)๋ก ๋ณด์ฌ์ค๋ค. ํ์ง๋ง ์ค์ ์๊ฐ์ 16:16:59(RT)๋ก 3์๊ฐ ์ ๋ ๋ฆ๋ค.
- ์ฌ๋ก๋ฉํ๊ณ ์๋ค๋ก ํ ํ๋ฉด์ผ๋ก ๊ฐ๋ค ๋์์๋ค ํด๋ด๋ ํ์ด์ง๋ ์๋ฌด๊ฒ๋ ๋ฐ๋์ง ์๋๋ค.
Keys to Emphasize
- getStaticProps function, this function is the key indicator that a page is using Static Site Generation.
- Fetched when running yarn build, the API will be hit ONLY when the application is building. This is why the time is at 13:39, while the real-time is 16:17.
- Data will not change because no further fetch, which is why the time shown is the same for each reloads.
- getStaticProps ํจ์, ์ด ํจ์๋ ํ์ด์ง๊ฐ Static Site Generation์ ์ฌ์ฉํ๊ณ ์๋ค๋ ํต์ฌ ์์์ด๋ค.
- yarn build๊ฐ ์คํ๋ ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ด, ์ ํ๋ฆฌ์ผ์ด์ ์ด ๋น๋๋ ๋์๋ง API์ ์ ๊ทผํ๋ค. ์ด๊ฒ์ด ์ค์ ์๊ฐ์ 16:17์ธ๋ฐ๋ 13:39๋ก ๋ณด์ฌ์ง๋ ์ด์ ์ด๋ค.
- ์ถ๊ฐ ํจ์น๊ฐ ์๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ๋ ๋ฐ๋์ง ์๋๋ค, ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๋งค๋ฒ ์ฌ๋ก๋ํ ๋๋ง๋ค ๋์ผํ ์๊ฐ์ ๋ณด์ฌ์ค๋ค.
Incremental Static Regeneration
Special function: `getStaticProps` + `revalidate`
Code Example
export default function ISR20Page({ dateTime }: ISR20PageProps) {
return (
<main>
<TimeSection dateTime={dateTime} />
</main>
);
}
export const getStaticProps: GetStaticProps = async () => {
const res = await axios.get('https://worldtimeapi.org/api/ip');
return {
props: { dateTime: res.data.datetime },
revalidate: 20,
};
};
Demo
Disclaimer: Revalidate time is set to 20 seconds.
์ฃผ์: ๊ฐฑ์ ์๊ฐ์ 20์ด๋ก ์ค์ ๋์ด ์์.
Video Description:
- At first, it was 16:40:12(PT), and real-time when reloading is 16:40:25(RT) and 16:40:29(RT). In those 2 reload, Preview Time (PT) did not change.
- Then, when 16:40:32(RT) (20s after initial), reload is done twice, the first time on 16:40:36(RT) and 16:40:40(RT). The Preview Time change to 16:40:37(PT) after the second reload.
- ๋งจ ์ฒ์ 16:40:12(PT)์๋ค. ๊ทธ๋ฆฌ๊ณ ์ฌ๋ก๋ฉ๋ ๋ ์ค์ ์๊ฐ์ 16:40:25(RT) ๊ทธ๋ฆฌ๊ณ 16:40:29(RT)์ด๋ค. ์ด 2๋ฒ์ ์ฌ๋ก๋์์, ๋ฏธ๋ฆฌ๋ณด๊ธฐ ์๊ฐ (PT)๋ ๋ณํ์ง ์๋๋ค.
- ๊ทธ๋ฆฌ๊ณ , 16:40:32(PT)์ผ ๋ (์ฒ์์ผ๋ก๋ถํฐ 20์ด ํ), ์ฌ๋ก๋๋ฅผ 2๋ฒ ํ์๋ค. ์ฒซ ๋ฒ์งธ๋ 16:40:36(RT)์ ๊ทธ๋ฆฌ๊ณ 16:40:40(RT)์ด์๋ค. ๋ฏธ๋ฆฌ๋ณด๊ธฐ ์๊ฐ์ 16:40:37(PT)๋ก ๋๋ฒ์งธ ์ฌ๋ก๋ ํ์ ๋ณ๊ฒฝ๋์๋ค.
Keys to Emphasize
Now, this is might be confusing for you, but here is the key I want you to look at.
์ข ํท๊ฐ๋ฆด ์๋ ์์ง๋ง ์ฌ๊ธฐ์ ๋ ์๋ค์ด ๋ณด์์ผ๋ฉด ํ๋ ํต์ฌ์ด ์๋ค.
- When in a 20-second cooldown span–16:40:12(RT) - 16:40:32(RT), reloading doesn't trigger changes. This is because the page is in a cooldown state, as we set on the revalidate key.
- After the 20-second cooldown–16:40:32(RT), we did 2 reloads.
- First Reload at 16:40:36(RT), we know that it is not on the cooldown state anymore. The first visit after the cooldown state is off, is going to trigger page rebuild. Page rebuild meaning, only this certain page is going to be rebuild. Not the whole application. The fetch API will run in the background, but there will be no changes on the Preview Time
- Second Full Reload at 16:40:40(RT), the Preview Time change to 16:40:37(PT). Exactly a second after the page rebuild (which means the rebuild takes about 1s). This second reload is going to serve that rebuilt page from the previous reload.
- 20์ด์ ์ฟจ๋ค์ด ๊ธฐ๊ฐ ๋์–16:40:12(RT) - 16:40:32(RT), ์ฌ๋ก๋๋ ๋ณ๊ฒฝ์ฌํญ์ด ํธ๋ฆฌ๊ฑฐ๋์ง ์๋๋ค. ์ด๊ฒ์ ์ฐ๋ฆฌ๊ฐ revalidate ํค๋ฅผ ์ค์ ํด๋์๋๋ก ํด๋น ํ์ด์ง๊ฐ ์ฟจ๋ค์ด ์ํ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
- 20์ด์ ์ฟจ๋ค์ด ํ์–16:40:32(RT), 2๋ฒ์ ์ฌ๋ก๋๋ฅผ ํ๋ค.
- ์ฒซ๋ฒ์งธ ์ฌ๋ก๋๋ 16:40:36(RT) ์ด์๋ค. ์ด ์์ ์ ๋ ์ด์ ์ฟจ๋ค์ด ์ํ์ ์์ง ์๋ค๋ ๊ฒ์ ์ฐ๋ฆฌ๋ ์๋ค. ์ฟจ๋ค์ด ์ํ๊ฐ ์ข ๋ฃ๋๊ณ ๋ ํ์ ์ฒซ๋ฒ์งธ ๋ฐฉ๋ฌธ์ ํ์ด์ง ์ฌ๋น๋๋ฅผ ํธ๋ฆฌ๊ฑฐ ํ๋ค. ํ์ด์ง ์ฌ๋น๋์ ์๋ฏธ๋ ํด๋น๋๋ ์ด ํน์ ํ์ด์ง๋ง ์ฌ๋น๋ ๋๋ค๋ ๊ฒ์ด๋ค. ์ ์ฒด ์ ํ๋ฆฌ์ผ์ด์ ์ด ์ฌ๋น๋ ๋๋ ๊ฒ์ด ์๋๋ค. ํจ์น API๋ ๋ฐฑ๊ทธ๋ผ์ด๋์์ ๋์ํ์ง๋ง ๋ฏธ๋ฆฌ๋ณด๊ธฐ ์๊ฐ์๋ ๋ณํ๊ฐ ์์ ๊ฒ์ด๋ค.
- ๋๋ฒ์งธ ์๋ก๊ณ ์นจ(*์๋์ ์ฉ์ด ์ค๋ช ์ด ๋์ด)๋ 16:40:40(RT)์ด๋ค. ๋ฏธ๋ฆฌ๋ณด๊ธฐ ์๊ฐ์ 16:40:37(PT)๋ก ๋ฐ๋์๋ค. ํ์ด์ง ์ฌ๋น๋๋๊ณ ์ ๋ง ์ ๊น ํ์ ๋ง์ด๋ค. (์ด๊ฒ์ ์ฌ๋น๋ํ๋๋ฐ ์ฝ 1์ด ์ ๋ ๊ฑธ๋ฆฐ๋ค๋ ๋ป์ด๋ค.) ์ด ๋๋ฒ์งธ ์ฌ๋ก๋๋ ์ด์ ์ฌ๋ก๋๋ก๋ถํฐ ์ฌ๋น๋๋ ํ์ด์ง๋ฅผ ๋ณด์ฌ์ค ๊ฒ์ด๋ค.
Revisiting Page vs Full Reload
Terms:
- Revisiting pages → navigating using next/link (going back to home, then to that page again)
- Full reload → doing reload at a website (command+r)
- ํ์ด์ง ์ฌ๋ฐฉ๋ฌธ → next/link๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ํ๋ ๊ฒ (ํ์ผ๋ก ๋์๊ฐ๋ค๊ฐ ํด๋น ํ์ด์ง๋ก ๋ค์ ์ค๋ ๊ฒ)
- ์๋ก๊ณ ์นจ → ์น์ฌ์ดํธ์์ ์๋ก๊ณ ์นจ/์ฌ๋ก๋ํ๋ ๊ฒ (command+r)
Video Description:
- Revisiting pages at the first time 18:38:45(RT), will trigger rebuild, but after the second revisit, the Preview Time did not change.
- After a full reload, then Preview Time is changed to 18:38:45(PT)
- 18:38:45(RT)์ ์ฒ์์ผ๋ก ํ์ด์ง๋ฅผ ์ฌ๋ฐฉ๋ฌธ ํ๋ ๊ฒ์, ์ฌ๋น๋๋ฅผ ํธ๋ฆฌ๊ฑฐํ ๊ฒ์ด์ง๋ง, ๋ ๋ฒ์งธ ์ฌ๋ฐฉ๋ฌธ ํ์ ๋ฏธ๋ฆฌ๋ณด๊ธฐ ์๊ฐ์ ๋ณํ์ง ์์๋ค.
- ์๋ก๊ณ ์นจํ์๋, ๋ฏธ๋ฆฌ๋ณด๊ธฐ ์๊ฐ์ด 18:38:45(PT)๋ก ๋ฐ๋์๋ค.
Note:
- The first reload does not have to be a full reload, we can go back to the home page, then to that page again (revisit), it will trigger the rebuild as long as we are not in the cooldown state.
- But, the second reload must be a full reload. Going back to the home page, then to the page again won't change the new Preview Time.
- ์ฒซ๋ฒ์งธ ์ฌ๋ก๋๋ ํ ์ฌ๋ก๋์ผ ํ์๋ ์๋ค. ํ ํ๋ฉด์ผ๋ก ๋์๊ฐ๋ค๊ฐ ํด๋น ํ์ด์ง๋ก ๋ค์ ๋์์๋ ๋๋ค(์ฌ๋ฐฉ๋ฌธ). ์ด๋ ๊ฒ ํ๋ ๊ฒ์ ์ฟจ๋ค์ด ์ํ๊ฐ ์๋ ํ ์ฌ๋น๋๋ฅผ ํธ๋ฆฌ๊ฑฐํ ๊ฒ์ด๋ค.
- ํ์ง๋ง, ๋๋ฒ์งธ ์ฌ๋ก๋๋ ๋ฐ๋์ ์๋ก๊ณ ์นจ์ด์ด์ผ๋ง ํ๋ค. ํ ํ๋ฉด์ผ๋ก ๋์๊ฐ๋ค๊ฐ ํด๋น ํ์ด์ง๋ก ๋ค์ ๋์์ค๋ ๊ฒ์ ์๋ก์ด ๋ฏธ๋ฆฌ๋ณด๊ธฐ ์๊ฐ์ผ๋ก ๋ฐ๊พธ์ง ์์ ๊ฒ์ด๋ค.
Now, this is a case where we are assuming that only 1 person is accessing the website. But, that reloads will happen every person visit while still respecting the cooldown state.
์ด๊ฒ์ ์ฐ๋ฆฌ๊ฐ ๋จ ํ ๋ช ๋ง์ด ์ด ์น์ฌ์ดํธ์ ์ ๊ทผํ๋ค๊ณ ๊ฐ์ ํ์ ๋์ด๋ค. ๊ทธ๋ฐ๋ฐ ์ด ์ฌ๋ก๋๋ ์ฟจ๋ค์ด ์ํ๋ฅผ ์ ์งํ๋ฉด์ ๋ฐฉ๋ฌธํ๋ ๋ชจ๋ ์ฌ๋์๊ฒ ๋ฐ์ํ๋ค.
Is it going to be rebuilt every 20s then?
๊ทธ๋ผ ๋งค 20์ด๋ง๋ค ์ฌ๋น๋๊ฐ ์ด๋ฃจ์ด์ง๋๊ฐ?
Nope.
๊ทธ๋ ์ง ์๋ค.
When the cooldown is off, if no one visits the page, then that page will not rebuild, even after long past the 20s.
์ฟจ๋ค์ด์ด ์ข ๋ฃ๋๊ณ ์๋ฌด๋ ํ์ด์ง๋ฅผ ๋ฐฉ๋ฌธํ์ง ์์ผ๋ฉด ํ์ด์ง๋ 20์ด๊ฐ ์ง๋ ํ์๋ ์ฌ๋น๋ ๋์ง ์์ ๊ฒ์ด๋ค.
But, the first person that visits when the cooldown state is off, is going to trigger a rebuild. That person won't be seeing changes. But, the changes will be served for the next full reload.
ํ์ง๋ง ์ฒซ ๋ฒ์งธ ์ฌ๋์ด ์ฟจ๋ค์ด ์ํ๊ฐ ์ข ๋ฃ๋์์ ๋ ๋ฐฉ๋ฌธํ๋ฉด ์ฌ๋น๋๋ ํธ๋ฆฌ๊ฑฐ ๋ ๊ฒ์ด๋ค. ๊ทธ ์ฌ๋์ ๋ฐ๋ ๋ด์ฉ์ ๋ณด์ง ๋ชปํ ๊ฒ์ด๋ค. ํ์ง๋ง ํด๋น ๋ณํ๋ ๋ค์ ์๋ก๊ณ ์นจ ๋์ ๋ณด์ฌ์ง ๊ฒ์ด๋ค.
Conclusion
That's all, folks!
If you have understood this material, I suggest you to read more about How to choose between them. I provide 4 metrics for you to consider and some example!
์ด ๊ธ์ ์ดํดํ๋ค๋ฉด, How to choose between them์ ๋ํด ๋ ์ฝ์ด๋ณด๊ธฐ ๋ฐ๋๋ค. ๋น์ ์ด ๊ณ ๋ คํด์ผํ 4๊ฐ์ง ์ธก์ ํญ๋ชฉ๊ณผ ๋ช ๊ฐ์ง ์์ ๋ ์ ๊ณตํ๋ค.
(๊ธ์ด ์ ์ตํ์ จ์ผ๋ฉด ์ํฐํด ์ ์์ ๋ธ๋ก๊ทธ์์ ์ข์์๋ ๋๋ฌ์ฃผ์ธ์๐๐)
๋ค์ ์ํฐํด How to choose between them ํ์ธํ๋ฌ๊ฐ๊ธฐ๐
'Next.js' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ด๋ณด๋ด๋ฒ] Next.js docs - next/image (v12.1.1) (0) | 2022.04.15 |
---|---|
[๋ด๋ณด๋ด๋ฒ] How to choose between Next.js CSR, SSR, SSG, and ISR (0) | 2022.03.07 |
[๋ด๋ณด๋ด๋ฒ] Next.js docs - Dynamic Import (2) | 2021.08.03 |
[๋ด๋ณด๋ด๋ฒ] Next.js docs - Authentication (2) | 2021.08.02 |
[๋ด๋ณด๋ด๋ฒ] Next.js docs - Deployment (0) | 2021.07.11 |