0Pricing
Next.js 15 Fullstack Web Apps · Ders

Sunucu Tarafı Önbelleğe Alma Stratejileri

Performansı artırmak için `fetch` seçeneklerini ve yeniden doğrulamayı kullanarak verileri sunucuda önbelleğe almayı öğrenin.

Sunucu Tarafı Önbelleğe Alma Stratejileri, CoddyKit'te ücretsiz bir Next.js 15 Fullstack Web Apps dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Next.js 15 Fullstack Web Apps öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Next.js 15 Fullstack Web Apps kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

Why Server-Side Caching?

In Next.js, server-side caching is crucial for building fast and efficient web applications. It helps reduce load times and server strain.

  • Performance: Delivers content faster to users.
  • Cost Reduction: Less frequent data fetches mean fewer API calls, potentially saving money.
  • Scalability: Handles more users without overloading your backend.

We'll explore how Next.js leverages the native fetch API for powerful caching.

Next.js `fetch` & Caching Defaults

When you use the native fetch API in Next.js Server Components, it automatically caches data by default. This is like having a built-in data store.

By default, fetch requests are cached using the 'force-cache' strategy. This means Next.js will look for a cached response first and use it if available, only fetching new data if no cache entry exists.

Disabling Cache: `cache: 'no-store'`

Sometimes, you need to ensure data is always fresh, like for real-time dashboards or sensitive user information. For these cases, you can disable caching for specific fetch requests.

Using cache: 'no-store' tells Next.js to always fetch fresh data from the origin server and never store it in the cache. This is useful for highly dynamic or frequently changing content.

`no-store` in Action

Here's how you'd use cache: 'no-store' in a Server Component to ensure you always get the latest user data.

async function getUserProfile(userId) {
  const res = await fetch(`https://api.example.com/users/${userId}`, {
    cache: 'no-store' // Always fetch fresh data
  });
  if (!res.ok) {
    throw new Error('Failed to fetch user profile');
  }
  return res.json();
}

export default async function ProfilePage({ params }) {
  const user = await getUserProfile(params.userId);
  return (
    <div>
      <h1>Welcome, {user.name}</h1>
      <p>Email: {user.email}</p>
    </div>
  );
}

Time-Based Revalidation

For data that changes periodically but not constantly, you can use time-based revalidation. This strategy is also known as "stale-while-revalidate".

You can specify a revalidate option within fetch's next property. It tells Next.js how often (in seconds) to re-fetch data in the background, serving cached data in the meantime.

  • next: { revalidate: 60 }: Data will be re-fetched at most every 60 seconds.

Revalidate Option Example

Let's say you have a blog post that updates every few minutes. You can use revalidate to keep it fresh without hitting the API on every single request.

async function getBlogPost(slug) {
  const res = await fetch(`https://api.example.com/posts/${slug}`, {
    next: { revalidate: 3600 } // Revalidate every hour
  });
  if (!res.ok) {
    throw new Error('Failed to fetch blog post');
  }
  return res.json();
}

export default async function BlogPostPage({ params }) {
  const post = await getBlogPost(params.slug);
  return (
    <div>
      <h1>{post.title}</h1>
      <p>{post.content}</p>
    </div>
  );
}

On-Demand Revalidation

What if you want to update cached data immediately after a change, like when a user publishes a new post? This is where on-demand revalidation comes in.

Next.js provides two functions for this:

  • revalidatePath('/path'): Invalidates the cache for a specific path.
  • revalidateTag('tag'): Invalidates the cache for all fetches associated with a specific tag.

These are typically used in Server Actions or API Routes after a data mutation.

Using `revalidateTag`

To use revalidateTag, you first need to tag your fetch requests. Then, from a Server Action or API Route, you can trigger a revalidation for that tag.

This allows fine-grained control over your cache, only clearing what's necessary when data actually changes.

async function getProducts() {
  const res = await fetch('https://api.example.com/products', {
    next: { tags: ['products'] } // Tag this fetch request
  });
  if (!res.ok) {
    throw new Error('Failed to fetch products');
  }
  return res.json();
}

// In a Server Action or API Route after adding/updating a product:
// import { revalidateTag } from 'next/cache';
// revalidateTag('products'); // Invalidate all fetches tagged 'products'

export default async function ProductsPage() {
  const products = await getProducts();
  return (
    <div>
      <h1>Our Products</h1>
      <ul>
        {products.map(product => (
          <li key={product.id}>{product.name}</li>
        ))}
      </ul>
    </div>
  );
}

Choosing the Right Strategy

Selecting the best caching strategy depends on your data's volatility:

  • cache: 'no-store': For highly dynamic, real-time, or sensitive data that must always be fresh.
  • next: { revalidate: N }: For data that updates periodically (e.g., news articles, blog posts) where some staleness is acceptable.
  • revalidatePath / revalidateTag: For data that changes unpredictably, often due to user actions (e.g., comments, e-commerce inventory), requiring immediate updates after mutation.

Caching Strategy Check

You are building a social media feed where posts are created and updated frequently. You want to ensure users see the latest posts without excessive API calls. Which caching strategy is most suitable for fetching the main feed?

Recap: Server-Side Caching

We've explored key server-side caching strategies in Next.js using the fetch API:

  • Default Caching: fetch uses 'force-cache' by default.
  • Disabling Cache: Use cache: 'no-store' for always-fresh data.
  • Time-Based Revalidation: Use next: { revalidate: N } for stale-while-revalidate.
  • On-Demand Revalidation: Use revalidatePath() or revalidateTag() in Server Actions/API Routes for immediate cache updates.

Mastering these techniques allows you to build highly performant and responsive Next.js applications!

Sıkça Sorulan Sorular

“Sunucu Tarafı Önbelleğe Alma Stratejileri” dersi ücretsiz mi?

Evet — “Sunucu Tarafı Önbelleğe Alma Stratejileri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Next.js 15 Fullstack Web Apps kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Next.js 15 Fullstack Web Apps kursu toplamda 4 dersten oluşur.

“Sunucu Tarafı Önbelleğe Alma Stratejileri” dersinde ne öğreneceğim?

Performansı artırmak için `fetch` seçeneklerini ve yeniden doğrulamayı kullanarak verileri sunucuda önbelleğe almayı öğrenin. Next.js 15 Fullstack Web Apps ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Next.js 15 Fullstack Web Apps öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Next.js 15 Fullstack Web Apps, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Sunucu Tarafı Önbelleğe Alma Stratejileri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Next.js 15 Fullstack Web Apps dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Next.js 15 Fullstack Web Apps dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Sunucu Durumu için React Query
  2. Zustand/Jotai ile İstemci Tarafı Durumu
  3. Sunucu Tarafı Önbelleğe Alma Stratejileri
  4. İyimser Güncellemeler ve Önbellek Geçersizleştirme
← Next.js 15 Fullstack Web Apps Sayfasına Dön