Serverkomponenter och datahämtning med tRPC
Förstå hur ni hämtar data direkt i Next.js-serverkomponenter med tRPC för optimal prestanda.
Serverkomponenter och datahämtning med tRPC är en gratis lektion i Typsäkra API:er från frontend till backend med tRPC på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Typsäkra API:er från frontend till backend med tRPC, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Typsäkra API:er från frontend till backend med tRPC innehåller totalt 4 lektioner.
Introduktion till Server Components
Välkommen! I Next.js är Server Components (SCs) en kraftfull funktion som låter dig rendera delar av användargränssnittet direkt på servern.
Det innebär att mindre JavaScript skickas till webbläsaren, att den första sidinläsningen går snabbare och att SEO förbättras!
Hämtning av data på servern
En viktig fördel med Server Components är att de kan hämta data direkt på servern. Till skillnad från Client Components behöver SCs inte göra API-anrop från webbläsaren.
Det gör att data kan hämtas och renderas innan sidan ens skickas till klienten, vilket förbättrar prestandan.
tRPC:s roll i SCs
Det är här tRPC verkligen kommer till sin rätt! När tRPC används i Server Components kan du anropa backendprocedurer direkt, utan någon HTTP-overhead.
Det är som att importera en lokal funktion, men med garanterad typsäkerhet från ände till ände tack vare tRPC och TypeScript.
Skapa en serveranropare
För att hämta data i Server Components behöver vi en särskild tRPC-klient som anropar procedurer direkt och kringgår HTTP. Detta kallas ofta en "server-side caller" eller "server client".
Den använder din tRPC-router direkt för att säkerställa typsäkerhet utan nätverksöverhead. Här är ett förenklat exempel:
import { appRouter } from '@/server/routers/_app';
import { createCallerFactory } from '@trpc/server';
// Create a tRPC caller that can be used on the server
const createCaller = createCallerFactory(appRouter);
export const serverClient = createCaller({});
// Context can be passed here, e.g., createCaller({ user: currentUser })Hämta data i en SC
Nu använder vi vår serverClient för att hämta data direkt i en Server Component i Next.js. Lägg märke till att det ser ut precis som att anropa en lokal funktion!
Data hämtas på servern innan komponenten renderas och skickas till klienten.
// app/page.tsx (Server Component)
import { serverClient } from '@/utils/trpc';
export default async function HomePage() {
const posts = await serverClient.post.list(); // Call a tRPC query
return (
<div>
<h1>Latest Posts</h1>
<ul>
{posts.map(post => (
<li key={post.id}>{post.title}</li>
))}
</ul>
</div>
);
}SC-data till Client Components
Server Components hämtar ofta data, men interaktioner i användargränssnittet sker i Client Components. Du kan skicka den hämtade datan som props från en SC till en CC.
Kom ihåg att märka klientkomponenter med "use client" högst upp.
// components/PostList.tsx (Client Component)
"use client";
interface Post {
id: string;
title: string;
}
export function PostList({ posts }: { posts: Post[] }) {
// Client-side interactions can happen here
return (
<ul>
{posts.map(post => (
<li key={post.id}>{post.title}</li>
))}
</ul>
);
}
// app/page.tsx (Server Component, updated)
import { serverClient } from '@/utils/trpc';
import { PostList } from '@/components/PostList';
export default async function HomePage() {
const posts = await serverClient.post.list();
return (
<div>
<h1>Latest Posts</h1>
<PostList posts={posts} /> {/* Pass data as props */}
</div>
);
}Frågor med indataparametrar
Precis som med vanliga tRPC-frågor kan du skicka indataparametrar till dina tRPC-anrop på serversidan. Det är användbart när du vill hämta specifika data baserat på URL-parametrar eller annan logik på serversidan.
// app/posts/[id]/page.tsx (Server Component)
import { serverClient } from '@/utils/trpc';
interface PostPageProps {
params: { id: string };
}
export default async function PostPage({ params }: PostPageProps) {
const { id } = params;
const post = await serverClient.post.byId({ id }); // Pass 'id' as input
if (!post) {
return <div>Post not found!</div>;
}
return (
<div>
<h1>{post.title}</h1>
<p>{post.content}</p>
</div>
);
}Robust felhantering
Fel som kastas av dina tRPC-procedurer på servern fortplantas till Server Component. Du kan använda vanliga JavaScript-block med try...catch för att hantera dem.
Det säkerställer att applikationen förblir robust även om datahämtningen misslyckas.
// app/page.tsx (Server Component with error handling)
import { serverClient } from '@/utils/trpc';
export default async function HomePage() {
let posts = [];
let error = null;
try {
posts = await serverClient.post.list();
} catch (e) {
console.error("Failed to fetch posts:", e);
error = "Could not load posts. Please try again.";
}
return (
<div>
<h1>Latest Posts</h1>
{error && <p style={{ color: 'red' }}>{error}</p>}
<ul>
{posts.map(post => (
<li key={post.id}>{post.title}</li>
))}
</ul>
</div>
);
}Datahämtning i SC jämfört med CC
När bör du använda Server Components för datahämtning i stället för Client Components (till exempel med React Query)?
- Server Components: Idealiska för initial data, SEO, statiskt/serverrenderat innehåll och för att minska storleken på klientens bundle.
- Client Components: Bäst för interaktiv data, realtidsuppdateringar, användarspecifik data efter den första inläsningen och mutationer.
Ofta använder du en kombination av båda!
Datahämtning i en Server Component
Föreställ dig ett Next.js-projekt med App Router som använder tRPC. Du behöver visa en lista över produkter vid den första sidinläsningen, och sidan ska vara snabb och SEO-vänlig.
Sammanfattning: SCs och tRPC
I den här lektionen utforskade vi hur data kan hämtas direkt i Next.js Server Components med hjälp av tRPC.
- Vi lärde oss att skapa en tRPC-anropare på serversidan.
- Hämtade data direkt i Server Components.
- Skickade hämtad data som props till Client Components.
- Hanterade frågeparametrar och fel i SCs.
- Förstod skillnaden mellan datahämtning i SC och CC.
Detta tillvägagångssätt kombinerar tRPC:s typsäkerhet med prestandafördelarna hos Server Components för robust och effektiv datahämtning.
Lär dig Typsäkra API:er från frontend till backend med tRPC med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 10
- Lektioner
- 40
Vanliga frågor
Är lektionen ”Serverkomponenter och datahämtning med tRPC” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Typsäkra API:er från frontend till backend med tRPC, inklusive ”Serverkomponenter och datahämtning med tRPC”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Typsäkra API:er från frontend till backend med tRPC innehåller totalt 4 lektioner.
Vad lär jag mig i ”Serverkomponenter och datahämtning med tRPC”?
Förstå hur ni hämtar data direkt i Next.js-serverkomponenter med tRPC för optimal prestanda. Ni övar på Typsäkra API:er från frontend till backend med tRPC med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Typsäkra API:er från frontend till backend med tRPC?
Du behöver inga förkunskaper. Utbildningen i Typsäkra API:er från frontend till backend med tRPC på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Serverkomponenter och datahämtning med tRPC”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Typsäkra API:er från frontend till backend med tRPC-lektionen?
Ja. Varje Typsäkra API:er från frontend till backend med tRPC-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- tRPC med Next.js App Router
- Avancerad integration med React Query
- Serverkomponenter och datahämtning med tRPC
- Optimistiska uppdateringar med tRPC-mutationer