SSR in Next.js What's New in App Routing Compared to Page Routing

Introduction

Next.js has long been a popular choice for building server-rendered React applications. With its built-in support for Server-Side Rendering (SSR), developers can create dynamic, SEO-friendly applications. However, the introduction of the App Router in Next.js 13 and the refinements in Next.js 14 have simplified and enhanced SSR significantly.

In this blog post, we'll explore the differences in SSR between the traditional Page Routing system and the newer App Routing system, highlighting how SSR works and how it's changed with the new routing paradigm.

SSR in Page Routing (Pre-Next.js 13)

Before the App Router was introduced, SSR was handled in the Page Routing system using specific functions like getServerSideProps. This function was called on every request, allowing developers to fetch data server-side before rendering the page.

Example of SSR in Page Routing using getServerSideProps:

export default function Blogs({ data }) {
  // Render the fetched data
  return (
    <div>
      {data.map((item) => (
        <div key={item.id}>
          <h3>{item.title}</h3>
          <p>{item.content}</p>
        </div>
      ))}
    </div>
  );
}

// This function runs on every request
export async function getServerSideProps() {
  // Fetch data from an external API
  const res = await fetch('https://api.example.com/blogs');
  const data = await res.json();

  // Pass the data as props to the page component
  return { props: { data } };
}

Here, getServerSideProps is the key to SSR in the Page Routing system. It allows you to fetch data from an API (or any other data source) on every request, and pass it to the page component as props. This pattern, while powerful, can result in complex codebases when handling a lot of server-side logic and different routes.

App Routing and SSR in Next.js 14

With Next.js 14, SSR has become more streamlined and integrated into the App Routing system. This new system introduces Server Components and Client Components, where SSR is much more intuitive.

In App Routing, you can now directly fetch data inside components without needing special functions like getServerSideProps. You can achieve this by using server actions, which makes the code simpler and easier to maintain.

Example of SSR in App Routing with Server Components:

"use server";

export async function getBlogs() {
  try {
    const response = await fetch('https://api.example.com/posts');
    return response.json();
  } catch (error) {
    return { error: error.message };
  }
}

// This component runs on the server and fetches data
export default async function Blog() {
  const blogs = await getBlogs();

  return (
    <div>
      {(blogs || []).map((blog) => (
        <div key={blog._id}>
          <h3>{blog.name}</h3>
          <p>{blog.content}</p>
        </div>
      ))}
    </div>
  );
}

In this App Routing example, we’re using a Server Component to fetch data directly inside the component file using use server. This removes the need for separate API routes or functions like getServerSideProps.

The Power of Server Actions
Next.js 14 simplifies the process by introducing server actions. These actions allow you to directly fetch and process data within the component file, reducing complexity and making your codebase more maintainable.

Key Benefits of server actions:

Cleaner Code: Instead of scattering server-side logic in separate files or functions, you can keep everything in one place.
Improved Maintainability: Fewer moving parts mean less code to manage, making your application easier to maintain.
Better Performance: With intelligent caching mechanisms, you can fine-tune your server-side logic for optimal performance.

Hydration in Next.js

In the context of Next.js and server-side rendering (SSR), hydration refers to the process where a statically-rendered HTML page (sent from the server) is converted into a fully interactive React application in the browser. It "hydrates" the static HTML with React's client-side JavaScript to make the page interactive.

Hydration in App Routing vs Page Routing

In Page Routing, hydration is required for every component on the page, making it interactive on the client side. This means all the JavaScript needed for interactions is shipped to the client, which can lead to performance bottlenecks as the application scales.

In App Routing, with Server Components, only the Client Components (those that handle interactivity) are hydrated. This selective hydration reduces the amount of JavaScript sent to the client, resulting in improved performance.

Example of Client Components in App Routing:

'use client';  // Mark this as a client component

export default function Button() {
  return (
    <button onClick={() => alert('Button clicked!')}>Click Me</button>
  );
}

Here, the Button component is marked as a Client Component with 'use client'. It allows for interactivity and runs on the client side, while other non-interactive components remain as Server Components, improving performance.

More About hydration in App Routing

Here's how it works:

Parent Components as Server Components:

The parent components (usually the higher-level components or entire page components) are typically Server Components. They run on the server and handle things like data fetching, rendering static HTML, and passing that data down to child components.
Since these are server-rendered, they do not include any JavaScript on the client-side, and they are not interactive.

Client Components for Interactivity:

Child components, which handle interactivity (like buttons, forms, etc.), are Client Components. These components can use React hooks (useState, useEffect, etc.) and are hydrated on the client-side.
Server Components pass data to these Client Components via props.
Once the HTML is loaded in the browser, Next.js hydrates the Client Components, attaching the necessary event listeners and making the page interactive.

// Server Component (Parent Component)
export default async function ParentComponent() {
  // Fetch data on the server
  const data = await fetch('https://api.example.com/data').then(res => res.json());

  return (
    <div>
      <h1>This is Server-Side Rendered</h1>
      <ClientComponent data={data} />
    </div>
  );
}

// Client Component (Child Component)
'use client';

import { useState } from 'react';

function ClientComponent({ data }) {
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>Data from server: {JSON.stringify(data)}</p>
      <p>Client-side counter: {count}</p>
      <button onClick={() => setCount(count + 1)}>Increment</button>
    </div>
  );
}

Conclusion

Next.js 14 makes Server-Side Rendering (SSR) easier and more powerful with the introduction of server actions in the App Router. By allowing developers to fetch data directly inside component files, this new system streamlines server-side logic, simplifies codebases, and reduces the need for separate API routes. Coupled with selective hydration, SSR in Next.js 14 is now faster and more efficient, helping you build highly dynamic and SEO-friendly applications with ease.

By leveraging these server actions, you can improve your app’s performance while keeping your code clean and maintainable. The shift from Page Routing to App Routing with Server and Client Components represents a major leap forward in building scalable web applications.

The above is the detailed content of SSR in Next.js What's New in App Routing Compared to Page Routing. For more information, please follow other related articles on the PHP Chinese website!