活动公告

系统通知
通知：由于主题天梯活动参与率不足，活动终止。后续将会替换为其他活动内容
07-12 12:44
系统通知
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

深入探索 Next.js 个性化路由配置的艺术 从基础原理到高级实践 打造符合现代 Web 应用需求的定制化路由解决方案

这是个蓝孩子 当前离线 威震华夏关云长
SunJu_FaceMall

3万

主题

2689

科技点

3万

积分

执行版主

碾压王

积分
32881

塔罗立华奏
执行版主 发表于 2025-8-29 15:40:00 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

Next.js 作为 React 生态中最流行的服务端渲染框架之一，以其强大的路由系统而著称。从早期的页面路由到最新的 App Router，Next.js 的路由系统一直在不断演进，以满足现代 Web 应用日益复杂的需求。本文将深入探讨 Next.js 路由系统的个性化配置，从基础原理到高级实践，帮助开发者打造符合现代 Web 应用需求的定制化路由解决方案。

路由是 Web 应用的骨架，它不仅决定了应用的 URL 结构，还影响着用户体验、代码组织方式、性能优化等多个方面。通过掌握 Next.js 路由配置的艺术，开发者可以构建出更加灵活、高效且易于维护的 Web 应用。

Next.js 路由基础

文件系统路由原理

Next.js 采用了基于文件系统的路由机制，这是其核心特性之一。在这种机制下，文件和目录结构直接映射到应用的 URL 路径，使得路由管理变得直观且易于维护。

在 Next.js 13 之前，主要使用的是 Pages Router，其路由规则如下：

• pages/index.js→/
• pages/about.js→/about
• pages/blog/[slug].js→/blog/:slug

而随着 Next.js 13 的发布，引入了全新的 App Router，基于 React Server Components，提供了更强大的路由功能：

• app/page.js→/
• app/about/page.js→/about
• app/blog/[slug]/page.js→/blog/:slug

路由类型对比

Next.js 提供了两种路由系统：传统的 Pages Router 和现代的 App Router。

Pages Router的特点：

• 简单直观，易于上手
• 支持静态生成(SSG)和服务端渲染(SSR)
• 通过getStaticProps、getServerSideProps等函数获取数据

App Router的特点：

• 基于 React Server Components
• 支持嵌套路由、布局和模板
• 更细粒度的渲染控制（Streaming SSR）
• 服务器组件和客户端组件的分离

下面是一个基础的 App Router 结构示例：
  2. // app/layout.js - 根布局
  3. export default function RootLayout({ children }) {
  4.   return (
  5.     <html lang="en">
  6.       <body>{children}</body>
  7.     </html>
  8.   );
  9. }
  11. // app/page.js - 首页
  12. export default function HomePage() {
  13.   return <h1>Welcome to Next.js!</h1>;
  14. }
  16. // app/about/page.js - 关于页面
  17. export default function AboutPage() {
  18.   return <h1>About Us</h1>;
  19. }
复制代码

基础路由配置

静态路由

静态路由是最简单的路由形式，直接对应文件系统中的文件。

在 App Router 中：
  2. // app/products/page.js
  3. export default function ProductsPage() {
  4.   return (
  5.     <div>
  6.       <h1>Our Products</h1>
  7.       <p>Check out our amazing product lineup!</p>
  8.     </div>
  9.   );
  10. }
复制代码

这将创建一个/products路径，访问该路径将显示ProductsPage组件。

动态路由

动态路由允许我们创建包含参数的 URL，例如产品详情页、用户个人资料页等。

在 App Router 中，动态路由通过方括号[]定义：
  2. // app/products/[id]/page.js
  3. export default function ProductPage({ params }) {
  4.   return (
  5.     <div>
  6.       <h1>Product Details</h1>
  7.       <p>Viewing product with ID: {params.id}</p>
  8.     </div>
  9.   );
  10. }
复制代码

这将匹配/products/1、/products/abc等路径，并将id参数传递给组件。

嵌套路由

嵌套路由允许我们在 URL 结构中创建层次关系，同时保持组件的嵌套结构。

在 App Router 中，嵌套路由通过创建嵌套文件夹实现：
  2. // app/dashboard/layout.js
  3. export default function DashboardLayout({ children }) {
  4.   return (
  5.     <div>
  6.       <nav>Dashboard Navigation</nav>
  7.       {children}
  8.     </div>
  9.   );
  10. }
  12. // app/dashboard/page.js
  13. export default function DashboardHome() {
  14.   return <h1>Dashboard Home</h1>;
  15. }
  17. // app/dashboard/settings/page.js
  18. export default function DashboardSettings() {
  19.   return <h1>Dashboard Settings</h1>;
  20. }
复制代码

这样，/dashboard将显示DashboardHome组件，而/dashboard/settings将显示DashboardSettings组件，两者都会被包裹在DashboardLayout中。

路由组

路由组允许我们在不影响 URL 路径的情况下组织文件。通过将文件夹放在括号中，如(marketing)，可以创建逻辑分组而不添加到 URL 中。
  2. // app/(marketing)/about/page.js
  3. export default function AboutPage() {
  4.   return <h1>About Us</h1>;
  5. }
  7. // app/(marketing)/contact/page.js
  8. export default function ContactPage() {
  9.   return <h1>Contact Us</h1>;
  10. }
复制代码

这些页面将分别对应/about和/contact路径，(marketing)文件夹名不会出现在 URL 中。

中间件与路由拦截

路由中间件基础

Next.js 中间件允许我们在请求完成之前运行代码，这对于实现路由守卫、重定向、身份验证等功能非常有用。

创建中间件文件middleware.js（或.ts）在项目根目录或与app目录同级：
  2. // middleware.js
  3. import { NextResponse } from 'next/server';
  4. import { nextAuth } from './lib/auth';
  6. export async function middleware(request) {
  7.   const { pathname } = request.nextUrl;
  8.   
  9.   // 检查用户是否已认证
  10.   const isAuthenticated = await nextAuth.isAuthenticated(request);
  11.   
  12.   // 如果访问受保护的路由但未认证，重定向到登录页
  13.   if (pathname.startsWith('/dashboard') && !isAuthenticated) {
  14.     return NextResponse.redirect(new URL('/login', request.url));
  15.   }
  16.   
  17.   return NextResponse.next();
  18. }
  20. // 配置中间件匹配的路径
  21. export const config = {
  22.   matcher: ['/dashboard/:path*', '/profile/:path*'],
  23. };
复制代码

高级中间件模式

中间件可以用于实现更复杂的路由拦截和修改逻辑：
  2. // middleware.js
  3. import { NextResponse } from 'next/server';
  5. export async function middleware(request) {
  6.   const { pathname, searchParams } = request.nextUrl;
  7.   const token = request.cookies.get('token')?.value;
  8.   
  9.   // A/B 测试路由分发
  10.   if (pathname === '/home') {
  11.     const variant = Math.random() > 0.5 ? 'a' : 'b';
  12.     return NextResponse.redirect(new URL(`/home-${variant}`, request.url));
  13.   }
  14.   
  15.   // 地理位置重定向
  16.   const country = request.geo?.country;
  17.   if (pathname === '/news' && country === 'CN') {
  18.     return NextResponse.redirect(new URL('/news/china', request.url));
  19.   }
  20.   
  21.   // API 速率限制
  22.   if (pathname.startsWith('/api/')) {
  23.     const clientIP = request.ip;
  24.     const rateLimitResult = await checkRateLimit(clientIP);
  25.    
  26.     if (!rateLimitResult.allowed) {
  27.       return new NextResponse('Too many requests', { status: 429 });
  28.     }
  29.   }
  30.   
  31.   // 添加自定义响应头
  32.   const response = NextResponse.next();
  33.   response.headers.set('X-Custom-Header', 'Custom Value');
  34.   
  35.   return response;
  36. }
  38. // 辅助函数：检查速率限制
  39. async function checkRateLimit(ip) {
  40.   // 实现速率限制逻辑
  41.   return { allowed: true };
  42. }
  44. export const config = {
  45.   matcher: [
  46.     '/((?!_next/static|_next/image|favicon.ico).*)',
  47.   ],
  48. };
复制代码

基于角色的访问控制

中间件还可以用于实现基于角色的访问控制（RBAC）：
  2. // middleware.js
  3. import { NextResponse } from 'next/server';
  4. import { verifyToken } from './lib/auth';
  6. export async function middleware(request) {
  7.   const { pathname } = request.nextUrl;
  8.   const token = request.cookies.get('auth_token')?.value;
  9.   
  10.   // 不需要认证的路径
  11.   const publicPaths = ['/login', '/register', '/'];
  12.   if (publicPaths.includes(pathname)) {
  13.     return NextResponse.next();
  14.   }
  15.   
  16.   // 验证令牌
  17.   if (!token) {
  18.     return NextResponse.redirect(new URL('/login', request.url));
  19.   }
  20.   
  21.   const user = await verifyToken(token);
  22.   
  23.   if (!user) {
  24.     return NextResponse.redirect(new URL('/login', request.url));
  25.   }
  26.   
  27.   // 基于角色的路由保护
  28.   const roleBasedPaths = {
  29.     '/admin': ['admin'],
  30.     '/dashboard': ['user', 'admin'],
  31.     '/settings': ['user', 'admin'],
  32.   };
  33.   
  34.   for (const [path, allowedRoles] of Object.entries(roleBasedPaths)) {
  35.     if (pathname.startsWith(path) && !allowedRoles.includes(user.role)) {
  36.       return NextResponse.redirect(new URL('/unauthorized', request.url));
  37.     }
  38.   }
  39.   
  40.   // 将用户信息添加到请求头中，以便在路由中使用
  41.   const requestHeaders = new Headers(request.headers);
  42.   requestHeaders.set('x-user-id', user.id);
  43.   requestHeaders.set('x-user-role', user.role);
  44.   
  45.   return NextResponse.next({
  46.     request: {
  47.       headers: requestHeaders,
  48.     },
  49.   });
  50. }
  52. export const config = {
  53.   matcher: [
  54.     '/((?!_next/static|_next/image|favicon.ico|api/auth).*)',
  55.   ],
  56. };
复制代码

高级路由模式

并行路由

并行路由允许在同一布局中同时渲染多个独立的页面，这对于创建复杂的应用界面（如仪表板）非常有用。

在 App Router 中，并行路由通过命名插槽实现：
  2. // app/dashboard/@analytics/page.js
  3. export default function Analytics() {
  4.   return <div>Analytics Panel</div>;
  5. }
  7. // app/dashboard/@team/page.js
  8. export default function Team() {
  9.   return <div>Team Panel</div>;
  10. }
  12. // app/dashboard/layout.js
  13. export default function DashboardLayout({
  14.   children,
  15.   analytics,
  16.   team,
  17. }) {
  18.   return (
  19.     <div className="dashboard">
  20.       <aside>{children}</aside>
  21.       <div className="main-content">
  22.         <section className="analytics">{analytics}</section>
  23.         <section className="team">{team}</section>
  24.       </div>
  25.     </div>
  26.   );
  27. }
复制代码

这样，当访问/dashboard时，将同时渲染默认的children、Analytics和Team组件。我们还可以通过路由如/dashboard/@analytics单独访问某个插槽。

拦截路由

拦截路由允许我们在当前页面的上下文中显示路由内容，而不离开当前页面。这对于模态框、抽屉等 UI 模式非常有用。
  2. // app/photos/[id]/page.js
  3. export default function PhotoPage({ params }) {
  4.   return <div>Viewing photo {params.id}</div>;
  5. }
  7. // app/@modal/(..)photos/[id]/page.js
  8. export default function PhotoModal({ params }) {
  9.   return (
  10.     <div className="modal">
  11.       <h2>Photo Modal</h2>
  12.       <p>Viewing photo {params.id} in a modal</p>
  13.     </div>
  14.   );
  15. }
  17. // app/layout.js
  18. import { Suspense } from 'react';
  20. export default function RootLayout({ children, modal }) {
  21.   return (
  22.     <html>
  23.       <body>
  24.         {children}
  25.         <Suspense fallback={null}>{modal}</Suspense>
  26.       </body>
  27.     </html>
  28.   );
  29. }
复制代码

通过这种方式，当用户点击照片链接时，可以在模态框中显示照片详情，而不离开当前页面。

条件路由

条件路由允许我们根据特定条件（如用户设备、地理位置、时间等）提供不同的路由体验。
  2. // app/page.js
  3. import { redirect } from 'next/navigation';
  4. import { isMobileDevice } from '@/lib/device';
  6. export default async function Home() {
  7.   const isMobile = await isMobileDevice();
  8.   
  9.   if (isMobile) {
  10.     redirect('/mobile-home');
  11.   }
  12.   
  13.   return <div>Desktop Home Page</div>;
  14. }
  16. // app/mobile-home/page.js
  17. export default function MobileHome() {
  18.   return <div>Mobile Home Page</div>;
  19. }
复制代码

动态路由与数据获取

动态路由通常需要根据路由参数获取数据。在 App Router 中，我们可以使用 React Server Components 直接在组件中获取数据：
  2. // app/blog/[slug]/page.js
  3. async function getBlogPost(slug) {
  4.   const res = await fetch(`https://api.example.com/blog/${slug}`, {
  5.     cache: 'force-cache', // 默认行为，静态生成
  6.     // 或者使用 { cache: 'no-store' } 进行动态渲染
  7.   });
  8.   
  9.   if (!res.ok) {
  10.     throw new Error('Failed to fetch blog post');
  11.   }
  12.   
  13.   return res.json();
  14. }
  16. export default async function BlogPostPage({ params }) {
  17.   const post = await getBlogPost(params.slug);
  18.   
  19.   return (
  20.     <article>
  21.       <h1>{post.title}</h1>
  22.       <div dangerouslySetInnerHTML={{ __html: post.content }} />
  23.     </article>
  24.   );
  25. }
复制代码

对于更复杂的数据获取场景，我们可以使用generateStaticParams函数预构建静态页面：
  2. // app/blog/[slug]/page.js
  3. async function getBlogSlugs() {
  4.   const res = await fetch('https://api.example.com/blog/slugs');
  5.   const slugs = await res.json();
  6.   return slugs;
  7. }
  9. export async function generateStaticParams() {
  10.   const slugs = await getBlogSlugs();
  11.   return slugs.map((slug) => ({ slug }));
  12. }
  14. // ...其余代码与上面相同
复制代码

路由优化与性能

代码分割与懒加载

Next.js 默认会对每个页面进行代码分割，但我们还可以进一步优化，通过动态导入实现组件级别的懒加载：
  2. // app/components/heavy-component.js
  3. export default function HeavyComponent() {
  4.   return <div>This is a heavy component with lots of dependencies</div>;
  5. }
  7. // app/page.js
  8. import dynamic from 'next/dynamic';
  10. // 动态导入 HeavyComponent，不进行 SSR
  11. const HeavyComponent = dynamic(
  12.   () => import('../components/heavy-component'),
  13.   { ssr: false }
  14. );
  16. // 带有加载状态的动态导入
  17. const HeavyComponentWithLoading = dynamic(
  18.   () => import('../components/heavy-component'),
  19.   {
  20.     loading: () => <p>Loading...</p>,
  21.     ssr: false
  22.   }
  23. );
  25. export default function HomePage() {
  26.   return (
  27.     <div>
  28.       <h1>Welcome to the Home Page</h1>
  29.       <HeavyComponent />
  30.       <HeavyComponentWithLoading />
  31.     </div>
  32.   );
  33. }
复制代码

路由预加载

Next.js 提供了<Link>组件的prefetch属性，可以在后台预加载页面资源，提高导航速度：
  2. // app/components/navigation.js
  3. import Link from 'next/link';
  5. export default function Navigation() {
  6.   return (
  7.     <nav>
  8.       <Link href="/" prefetch={true}>Home</Link>
  9.       <Link href="/about" prefetch={true}>About</Link>
  10.       <Link href="/contact" prefetch={true}>Contact</Link>
  11.     </nav>
  12.   );
  13. }
复制代码

对于更精细的控制，我们可以使用router.prefetch方法：
  2. // app/components/product-card.js
  3. 'use client';
  5. import { useRouter } from 'next/navigation';
  6. import { useEffect } from 'react';
  8. export default function ProductCard({ product }) {
  9.   const router = useRouter();
  10.   
  11.   useEffect(() => {
  12.     // 当鼠标悬停在卡片上时预加载产品详情页
  13.     router.prefetch(`/products/${product.id}`);
  14.   }, [product.id, router]);
  15.   
  16.   return (
  17.     <div
  18.       onClick={() => router.push(`/products/${product.id}`)}
  19.       style={{ cursor: 'pointer' }}
  20.     >
  21.       <h3>{product.name}</h3>
  22.       <p>{product.description}</p>
  23.     </div>
  24.   );
  25. }
复制代码

缓存策略优化

在 App Router 中，我们可以通过fetchAPI 的cache选项精细控制数据缓存策略：
  2. // app/products/page.js
  3. async function getProducts() {
  4.   // 使用默认缓存（静态生成）
  5.   const res = await fetch('https://api.example.com/products');
  6.   return res.json();
  7. }
  9. async function getRealTimeData() {
  10.   // 不缓存，每次请求都重新获取
  11.   const res = await fetch('https://api.example.com/real-time-data', {
  12.     cache: 'no-store',
  13.   });
  14.   return res.json();
  15. }
  17. async function getRevalidatedData() {
  18.   // 缓存数据，但最多 60 秒后重新验证
  19.   const res = await fetch('https://api.example.com/revalidated-data', {
  20.     next: { revalidate: 60 },
  21.   });
  22.   return res.json();
  23. }
  25. export default async function ProductsPage() {
  26.   const products = await getProducts();
  27.   const realTimeData = await getRealTimeData();
  28.   const revalidatedData = await getRevalidatedData();
  29.   
  30.   return (
  31.     <div>
  32.       <h1>Products</h1>
  33.       {/* 渲染产品列表 */}
  34.     </div>
  35.   );
  36. }
复制代码

路由级性能优化

我们可以通过路由配置实现更细粒度的性能优化：
  2. // app/shop/[category]/[product]/page.js
  3. import { unstable_cache } from 'next/cache';
  5. async function getProduct(category, product) {
  6.   // 使用不稳定缓存 API 缓存数据获取函数
  7.   const getProductData = unstable_cache(
  8.     async () => {
  9.       const res = await fetch(`https://api.example.com/shop/${category}/${product}`);
  10.       return res.json();
  11.     },
  12.     [`product-${category}-${product}`],
  13.     {
  14.       revalidate: 3600, // 1 小时后重新验证
  15.       tags: [`product-${product}`], // 用于按需重新验证
  16.     }
  17.   );
  18.   
  19.   return getProductData();
  20. }
  22. export default async function ProductPage({ params }) {
  23.   const product = await getProduct(params.category, params.product);
  24.   
  25.   return (
  26.     <div>
  27.       <h1>{product.name}</h1>
  28.       <p>{product.description}</p>
  29.       <p>Price: ${product.price}</p>
  30.     </div>
  31.   );
  32. }
  34. // 按需重新验证的 API 路由
  35. // app/api/revalidate/route.js
  36. import { revalidateTag } from 'next/cache';
  38. export async function POST(request) {
  39.   const { tag } = await request.json();
  40.   
  41.   revalidateTag(tag);
  42.   
  43.   return Response.json({ revalidated: true, now: Date.now() });
  44. }
复制代码

自定义路由配置

next.config.js 路由配置

通过next.config.js文件，我们可以实现更高级的路由配置：
  2. // next.config.js
  3. module.exports = {
  4.   // 自定义页面扩展名
  5.   pageExtensions: ['jsx', 'js', 'tsx', 'ts'],
  6.   
  7.   // 路径别名
  8.   webpack: (config) => {
  9.     config.resolve.alias = {
  10.       ...config.resolve.alias,
  11.       '@components': './components',
  12.       '@lib': './lib',
  13.     };
  14.     return config;
  15.   },
  16.   
  17.   // 重写和重定向
  18.   async rewrites() {
  19.     return [
  20.       {
  21.         source: '/dashboard',
  22.         destination: '/dashboard/overview',
  23.       },
  24.       {
  25.         source: '/blog/:slug',
  26.         destination: '/articles/:slug',
  27.       },
  28.     ];
  29.   },
  30.   
  31.   async redirects() {
  32.     return [
  33.       {
  34.         source: '/old-home',
  35.         destination: '/',
  36.         permanent: true,
  37.       },
  38.       {
  39.         source: '/admin/:path*',
  40.         destination: '/dashboard/:path*',
  41.         permanent: false,
  42.       },
  43.     ];
  44.   },
  45.   
  46.   // 头部配置
  47.   async headers() {
  48.     return [
  49.       {
  50.         source: '/(.*)',
  51.         headers: [
  52.           {
  53.             key: 'X-Frame-Options',
  54.             value: 'DENY',
  55.           },
  56.           {
  57.             key: 'X-Content-Type-Options',
  58.             value: 'nosniff',
  59.           },
  60.         ],
  61.       },
  62.     ];
  63.   },
  64. };
复制代码

自定义路由处理

我们可以创建自定义路由处理程序来处理特定的路由模式：
  2. // app/api/route.js
  3. import { NextResponse } from 'next/server';
  5. export async function GET(request) {
  6.   const { searchParams } = new URL(request.url);
  7.   const id = searchParams.get('id');
  8.   
  9.   const data = await fetchData(id);
  10.   
  11.   return NextResponse.json(data);
  12. }
  14. export async function POST(request) {
  15.   const body = await request.json();
  16.   
  17.   const result = await createData(body);
  18.   
  19.   return NextResponse.json(result, { status: 201 });
  20. }
复制代码

国际化路由配置

Next.js 提供了内置的国际化(i18n)支持，我们可以配置基于子路径或域名的多语言路由：
  2. // next.config.js
  3. module.exports = {
  4.   i18n: {
  5.     locales: ['en', 'fr', 'de'],
  6.     defaultLocale: 'en',
  7.     domains: [
  8.       {
  9.         domain: 'example.com',
  10.         defaultLocale: 'en',
  11.       },
  12.       {
  13.         domain: 'example.fr',
  14.         defaultLocale: 'fr',
  15.       },
  16.       {
  17.         domain: 'example.de',
  18.         defaultLocale: 'de',
  19.       },
  20.     ],
  21.   },
  22. };
复制代码

然后，我们可以创建基于语言的路由结构：
  2. // app/[locale]/layout.js
  3. import { NextIntlClientProvider } from 'next-intl';
  4. import { getMessages } from 'next-intl/server';
  5. import { notFound } from 'next/navigation';
  7. const locales = ['en', 'fr', 'de'];
  9. export default async function LocaleLayout({
  10.   children,
  11.   params: { locale }
  12. }) {
  13.   // 验证是否提供了有效的 locale
  14.   if (!locales.includes(locale as any)) notFound();
  15.   
  16.   // 提供所有消息，以便在客户端组件中使用
  17.   const messages = await getMessages();
  18.   
  19.   return (
  20.     <NextIntlClientProvider messages={messages}>
  21.       {children}
  22.     </NextIntlClientProvider>
  23.   );
  24. }
  26. // app/[locale]/page.js
  27. export default function HomePage() {
  28.   return (
  29.     <div>
  30.       <h1>Welcome to the Home Page</h1>
  31.       {/* 本地化内容 */}
  32.     </div>
  33.   );
  34. }
复制代码

动态路由生成

对于需要动态生成大量路由的场景，我们可以使用generateStaticParams结合外部数据源：
  2. // app/docs/[...slug]/page.js
  3. async function getAllDocPaths() {
  4.   const res = await fetch('https://api.example.com/docs/paths');
  5.   const paths = await res.json();
  6.   return paths;
  7. }
  9. export async function generateStaticParams() {
  10.   const paths = await getAllDocPaths();
  11.   
  12.   return paths.map((path) => ({
  13.     slug: path.split('/'),
  14.   }));
  15. }
  17. export default async function DocPage({ params }) {
  18.   const { slug } = params;
  19.   const path = slug.join('/');
  20.   
  21.   const res = await fetch(`https://api.example.com/docs/${path}`);
  22.   const doc = await res.json();
  23.   
  24.   return (
  25.     <div>
  26.       <h1>{doc.title}</h1>
  27.       <div dangerouslySetInnerHTML={{ __html: doc.content }} />
  28.     </div>
  29.   );
  30. }
复制代码

实战案例

构建多租户 SaaS 应用路由

让我们构建一个具有多租户支持的 SaaS 应用路由系统：
  2. // middleware.js
  3. import { NextResponse } from 'next/server';
  5. export async function middleware(request) {
  6.   const { pathname, host } = request.nextUrl;
  7.   
  8.   // 从主机名提取租户信息
  9.   const subdomain = host.split('.')[0];
  10.   
  11.   // 跳过静态资源和 API 路由
  12.   if (
  13.     pathname.startsWith('/_next') ||
  14.     pathname.startsWith('/api') ||
  15.     pathname.startsWith('/static')
  16.   ) {
  17.     return NextResponse.next();
  18.   }
  19.   
  20.   // 租户特定的重定向
  21.   if (pathname === '/') {
  22.     return NextResponse.redirect(new URL(`/dashboard`, request.url));
  23.   }
  24.   
  25.   // 添加租户信息到请求头
  26.   const requestHeaders = new Headers(request.headers);
  27.   requestHeaders.set('x-tenant', subdomain);
  28.   
  29.   return NextResponse.next({
  30.     request: {
  31.       headers: requestHeaders,
  32.     },
  33.   });
  34. }
  36. export const config = {
  37.   matcher: [
  38.     '/((?!_next/static|_next/image|favicon.ico|api/auth).*)',
  39.   ],
  40. };
复制代码
  2. // app/layout.js
  3. import './globals.css';
  5. export const metadata = {
  6.   title: 'Multi-tenant SaaS Application',
  7.   description: 'A demo of multi-tenant routing in Next.js',
  8. };
  10. export default function RootLayout({ children }) {
  11.   return (
  12.     <html lang="en">
  13.       <body>{children}</body>
  14.     </html>
  15.   );
  16. }
复制代码
  2. // app/dashboard/layout.js
  3. import { Suspense } from 'react';
  4. import TenantProvider from '@/components/TenantProvider';
  6. export default function DashboardLayout({
  7.   children,
  8.   analytics,
  9.   settings,
  10. }) {
  11.   return (
  12.     <TenantProvider>
  13.       <div className="dashboard">
  14.         <aside>
  15.           <nav>
  16.             {/* 租户特定的导航 */}
  17.           </nav>
  18.         </aside>
  19.         <main>
  20.           <Suspense fallback={<div>Loading...</div>}>
  21.             {children}
  22.           </Suspense>
  23.         </main>
  24.         <div className="panels">
  25.           <Suspense fallback={<div>Loading analytics...</div>}>
  26.             {analytics}
  27.           </Suspense>
  28.           <Suspense fallback={<div>Loading settings...</div>}>
  29.             {settings}
  30.           </Suspense>
  31.         </div>
  32.       </div>
  33.     </TenantProvider>
  34.   );
  35. }
复制代码
  2. // app/components/TenantProvider.js
  3. 'use client';
  5. import { createContext, useContext, useEffect, useState } from 'react';
  7. const TenantContext = createContext();
  9. export function TenantProvider({ children }) {
  10.   const [tenant, setTenant] = useState(null);
  11.   const [loading, setLoading] = useState(true);
  12.   
  13.   useEffect(() => {
  14.     async function loadTenant() {
  15.       try {
  16.         // 从 API 获取租户信息
  17.         const res = await fetch('/api/tenant');
  18.         const data = await res.json();
  19.         setTenant(data);
  20.       } catch (error) {
  21.         console.error('Failed to load tenant:', error);
  22.       } finally {
  23.         setLoading(false);
  24.       }
  25.     }
  26.    
  27.     loadTenant();
  28.   }, []);
  29.   
  30.   if (loading) {
  31.     return <div>Loading tenant information...</div>;
  32.   }
  33.   
  34.   return (
  35.     <TenantContext.Provider value={{ tenant }}>
  36.       {children}
  37.     </TenantContext.Provider>
  38.   );
  39. }
  41. export function useTenant() {
  42.   return useContext(TenantContext);
  43. }
复制代码
  2. // app/api/tenant/route.js
  3. import { headers } from 'next/headers';
  5. export async function GET() {
  6.   const headersList = headers();
  7.   const tenantSubdomain = headersList.get('x-tenant');
  8.   
  9.   // 根据子域名获取租户信息
  10.   // 这里可以是数据库查询或其他数据源
  11.   const tenant = await getTenantBySubdomain(tenantSubdomain);
  12.   
  13.   if (!tenant) {
  14.     return Response.json({ error: 'Tenant not found' }, { status: 404 });
  15.   }
  16.   
  17.   return Response.json(tenant);
  18. }
  20. async function getTenantBySubdomain(subdomain) {
  21.   // 模拟数据库查询
  22.   const tenants = {
  23.     'client1': { id: 1, name: 'Client 1', theme: 'light' },
  24.     'client2': { id: 2, name: 'Client 2', theme: 'dark' },
  25.   };
  26.   
  27.   return tenants[subdomain] || null;
  28. }
复制代码

构建电子商务网站路由

让我们构建一个具有复杂路由需求的电子商务网站：
  2. // middleware.js
  3. import { NextResponse } from 'next/server';
  5. export async function middleware(request) {
  6.   const { pathname, searchParams } = request.nextUrl;
  7.   
  8.   // 从查询参数获取优惠码
  9.   const couponCode = searchParams.get('coupon');
  10.   
  11.   if (couponCode) {
  12.     // 验证优惠码
  13.     const isValid = await validateCoupon(couponCode);
  14.    
  15.     if (isValid) {
  16.       // 将优惠码存储在 cookie 中
  17.       const response = NextResponse.next();
  18.       response.cookies.set('coupon_code', couponCode, {
  19.         maxAge: 60 * 60 * 24, // 1 天
  20.         httpOnly: true,
  21.       });
  22.       return response;
  23.     }
  24.   }
  25.   
  26.   // 产品类别重定向
  27.   if (pathname.startsWith('/products/')) {
  28.     const category = pathname.split('/')[2];
  29.    
  30.     // 检查类别是否存在
  31.     const categoryExists = await checkCategoryExists(category);
  32.    
  33.     if (!categoryExists) {
  34.       return NextResponse.redirect(new URL('/products', request.url));
  35.     }
  36.   }
  37.   
  38.   return NextResponse.next();
  39. }
  41. async function validateCoupon(code) {
  42.   // 实现优惠码验证逻辑
  43.   return true;
  44. }
  46. async function checkCategoryExists(category) {
  47.   // 实现类别检查逻辑
  48.   return true;
  49. }
  51. export const config = {
  52.   matcher: [
  53.     '/((?!_next/static|_next/image|favicon.ico).*)',
  54.   ],
  55. };
复制代码
  2. // app/products/page.js
  3. import ProductGrid from '@/components/ProductGrid';
  4. import Filters from '@/components/Filters';
  5. import SortOptions from '@/components/SortOptions';
  7. async function getProducts({ searchParams }) {
  8.   const { category, sort, minPrice, maxPrice } = searchParams;
  9.   
  10.   const params = new URLSearchParams();
  11.   if (category) params.append('category', category);
  12.   if (sort) params.append('sort', sort);
  13.   if (minPrice) params.append('minPrice', minPrice);
  14.   if (maxPrice) params.append('maxPrice', maxPrice);
  15.   
  16.   const res = await fetch(`https://api.example.com/products?${params}`);
  17.   return res.json();
  18. }
  20. async function getCategories() {
  21.   const res = await fetch('https://api.example.com/categories');
  22.   return res.json();
  23. }
  25. export default async function ProductsPage({ searchParams }) {
  26.   const products = await getProducts({ searchParams });
  27.   const categories = await getCategories();
  28.   
  29.   return (
  30.     <div className="products-page">
  31.       <h1>Our Products</h1>
  32.       
  33.       <div className="filters-sidebar">
  34.         <Filters categories={categories} />
  35.       </div>
  36.       
  37.       <div className="products-content">
  38.         <SortOptions />
  39.         <ProductGrid products={products} />
  40.       </div>
  41.     </div>
  42.   );
  43. }
复制代码
  2. // app/products/[category]/page.js
  3. import ProductGrid from '@/components/ProductGrid';
  4. import Filters from '@/components/Filters';
  5. import SortOptions from '@/components/SortOptions';
  7. async function getProductsByCategory(category, { searchParams }) {
  8.   const { sort, minPrice, maxPrice } = searchParams;
  9.   
  10.   const params = new URLSearchParams();
  11.   params.append('category', category);
  12.   if (sort) params.append('sort', sort);
  13.   if (minPrice) params.append('minPrice', minPrice);
  14.   if (maxPrice) params.append('maxPrice', maxPrice);
  15.   
  16.   const res = await fetch(`https://api.example.com/products?${params}`);
  17.   return res.json();
  18. }
  20. async function getCategoryDetails(category) {
  21.   const res = await fetch(`https://api.example.com/categories/${category}`);
  22.   return res.json();
  23. }
  25. export async function generateStaticParams() {
  26.   const res = await fetch('https://api.example.com/categories');
  27.   const categories = await res.json();
  28.   
  29.   return categories.map((category) => ({
  30.     category: category.slug,
  31.   }));
  32. }
  34. export default async function CategoryPage({ params, searchParams }) {
  35.   const { category } = params;
  36.   const products = await getProductsByCategory(category, { searchParams });
  37.   const categoryDetails = await getCategoryDetails(category);
  38.   
  39.   return (
  40.     <div className="category-page">
  41.       <h1>{categoryDetails.name}</h1>
  42.       <p>{categoryDetails.description}</p>
  43.       
  44.       <div className="filters-sidebar">
  45.         <Filters />
  46.       </div>
  47.       
  48.       <div className="products-content">
  49.         <SortOptions />
  50.         <ProductGrid products={products} />
  51.       </div>
  52.     </div>
  53.   );
  54. }
复制代码
  2. // app/products/[category]/[slug]/page.js
  3. import { notFound } from 'next/navigation';
  4. import ProductGallery from '@/components/ProductGallery';
  5. import ProductInfo from '@/components/ProductInfo';
  6. import RelatedProducts from '@/components/RelatedProducts';
  7. import AddToCartButton from '@/components/AddToCartButton';
  9. async function getProduct(category, slug) {
  10.   const res = await fetch(`https://api.example.com/products/${slug}`, {
  11.     next: { revalidate: 3600 }, // 1 小时后重新验证
  12.   });
  13.   
  14.   if (!res.ok) {
  15.     return null;
  16.   }
  17.   
  18.   return res.json();
  19. }
  21. async function getRelatedProducts(productId) {
  22.   const res = await fetch(`https://api.example.com/products/${productId}/related`);
  23.   return res.json();
  24. }
  26. export async function generateStaticParams() {
  27.   const res = await fetch('https://api.example.com/products');
  28.   const products = await res.json();
  29.   
  30.   return products.map((product) => ({
  31.     category: product.category.slug,
  32.     slug: product.slug,
  33.   }));
  34. }
  36. export default async function ProductPage({ params }) {
  37.   const { category, slug } = params;
  38.   const product = await getProduct(category, slug);
  39.   
  40.   if (!product) {
  41.     notFound();
  42.   }
  43.   
  44.   const relatedProducts = await getRelatedProducts(product.id);
  45.   
  46.   return (
  47.     <div className="product-page">
  48.       <div className="product-main">
  49.         <ProductGallery images={product.images} />
  50.         <div className="product-details">
  51.           <ProductInfo product={product} />
  52.           <AddToCartButton product={product} />
  53.         </div>
  54.       </div>
  55.       
  56.       <div className="related-products">
  57.         <h2>You might also like</h2>
  58.         <RelatedProducts products={relatedProducts} />
  59.       </div>
  60.     </div>
  61.   );
  62. }
复制代码

最佳实践与注意事项

路由组织最佳实践

1. 保持路由结构简单直观：遵循 Next.js 的约定优于配置原则，尽量使用文件系统路由。
2. 合理使用路由组：使用路由组(folder-name)组织相关页面，而不影响 URL 结构。
3. 避免过度嵌套：过深的路由嵌套会使应用变得复杂，尽量保持路由层次扁平。
4. 使用布局减少代码重复：将共享的 UI 元素（如导航、页脚）放在布局组件中。

保持路由结构简单直观：遵循 Next.js 的约定优于配置原则，尽量使用文件系统路由。

合理使用路由组：使用路由组(folder-name)组织相关页面，而不影响 URL 结构。

避免过度嵌套：过深的路由嵌套会使应用变得复杂，尽量保持路由层次扁平。

使用布局减少代码重复：将共享的 UI 元素（如导航、页脚）放在布局组件中。
  2. // 良好的路由组织示例
  3. app/
  4. ├── (auth)/
  5. │   ├── login/
  6. │   │   └── page.js
  7. │   └── register/
  8. │       └── page.js
  9. ├── (dashboard)/
  10. │   ├── layout.js
  11. │   ├── page.js
  12. │   ├── analytics/
  13. │   │   └── page.js
  14. │   └── settings/
  15. │       └── page.js
  16. ├── (marketing)/
  17. │   ├── about/
  18. │   │   └── page.js
  19. │   └── contact/
  20. │       └── page.js
  21. ├── api/
  22. │   └── auth/
  23. │       └── route.js
  24. ├── layout.js
  25. └── page.js
复制代码

性能优化最佳实践

1. 使用静态生成：对于不经常变化的内容，使用静态生成（SSG）提高性能。
2. 实现增量静态再生成：对于需要定期更新的内容，使用 ISR。
3. 懒加载非关键组件：使用next/dynamic懒加载大型组件或非首屏组件。
4. 优化数据获取：在服务器组件中获取数据，减少客户端 JavaScript 包大小。
5. 使用预加载：对于用户可能访问的页面，使用<Link prefetch>或router.prefetch()预加载。

使用静态生成：对于不经常变化的内容，使用静态生成（SSG）提高性能。

实现增量静态再生成：对于需要定期更新的内容，使用 ISR。

懒加载非关键组件：使用next/dynamic懒加载大型组件或非首屏组件。

优化数据获取：在服务器组件中获取数据，减少客户端 JavaScript 包大小。

使用预加载：对于用户可能访问的页面，使用<Link prefetch>或router.prefetch()预加载。
  2. // 性能优化示例
  3. import dynamic from 'next/dynamic';
  4. import Link from 'next/link';
  6. // 懒加载大型组件
  7. const HeavyChart = dynamic(
  8.   () => import('../components/HeavyChart'),
  9.   {
  10.     loading: () => <div>Loading chart...</div>,
  11.     ssr: false
  12.   }
  13. );
  15. // 预加载页面
  16. function Navigation() {
  17.   return (
  18.     <nav>
  19.       <Link href="/dashboard" prefetch={true}>Dashboard</Link>
  20.       <Link href="/analytics" prefetch={true}>Analytics</Link>
  21.     </nav>
  22.   );
  23. }
  25. // 服务器组件中获取数据
  26. async function BlogPage() {
  27.   const posts = await getBlogPosts(); // 在服务器上获取数据
  28.   
  29.   return (
  30.     <div>
  31.       <h1>Blog Posts</h1>
  32.       {posts.map(post => (
  33.         <div key={post.id}>
  34.           <h2>{post.title}</h2>
  35.           <p>{post.excerpt}</p>
  36.         </div>
  37.       ))}
  38.     </div>
  39.   );
  40. }
复制代码

安全性最佳实践

1. 验证路由参数：始终验证动态路由参数，防止恶意输入。
2. 实现适当的认证和授权：使用中间件保护敏感路由。
3. 避免在 URL 中暴露敏感信息：不要将敏感数据（如 ID、令牌）放在 URL 中。
4. 使用 HTTPS：确保所有路由都通过 HTTPS 提供服务。

验证路由参数：始终验证动态路由参数，防止恶意输入。

实现适当的认证和授权：使用中间件保护敏感路由。

避免在 URL 中暴露敏感信息：不要将敏感数据（如 ID、令牌）放在 URL 中。

使用 HTTPS：确保所有路由都通过 HTTPS 提供服务。
  2. // 安全路由参数验证示例
  3. export default function UserProfilePage({ params }) {
  4.   const { userId } = params;
  5.   
  6.   // 验证 userId 是否为有效的 UUID
  7.   if (!isValidUUID(userId)) {
  8.     notFound();
  9.   }
  10.   
  11.   // 获取用户数据
  12.   const user = getUserById(userId);
  13.   
  14.   if (!user) {
  15.     notFound();
  16.   }
  17.   
  18.   // 检查当前用户是否有权查看此用户资料
  19.   if (!canViewUserProfile(user)) {
  20.     redirect('/unauthorized');
  21.   }
  22.   
  23.   return <UserProfile user={user} />;
  24. }
  26. // 中间件认证示例
  27. export async function middleware(request) {
  28.   const token = request.cookies.get('auth_token')?.value;
  29.   
  30.   // 检查令牌是否存在
  31.   if (!token) {
  32.     return NextResponse.redirect(new URL('/login', request.url));
  33.   }
  34.   
  35.   // 验证令牌
  36.   const user = await verifyToken(token);
  37.   
  38.   if (!user) {
  39.     // 删除无效令牌
  40.     const response = NextResponse.redirect(new URL('/login', request.url));
  41.     response.cookies.delete('auth_token');
  42.     return response;
  43.   }
  44.   
  45.   // 将用户信息添加到请求头
  46.   const requestHeaders = new Headers(request.headers);
  47.   requestHeaders.set('x-user-id', user.id);
  48.   requestHeaders.set('x-user-role', user.role);
  49.   
  50.   return NextResponse.next({
  51.     request: {
  52.       headers: requestHeaders,
  53.     },
  54.   });
  55. }
复制代码

可访问性最佳实践

1. 使用语义 HTML：确保路由结构使用适当的 HTML5 语义元素。
2. 提供导航辅助功能：包括跳过导航链接、面包屑导航等。
3. 管理焦点：页面导航时适当管理键盘焦点。
4. 提供有意义的页面标题：每个页面应有描述性的标题。

使用语义 HTML：确保路由结构使用适当的 HTML5 语义元素。

提供导航辅助功能：包括跳过导航链接、面包屑导航等。

管理焦点：页面导航时适当管理键盘焦点。

提供有意义的页面标题：每个页面应有描述性的标题。
  2. // 可访问性路由示例
  3. // app/layout.js
  4. export default function RootLayout({ children }) {
  5.   return (
  6.     <html lang="en">
  7.       <body>
  8.         <a href="#main-content" className="skip-link">
  9.           Skip to main content
  10.         </a>
  11.         <nav aria-label="Main navigation">
  12.           {/* 导航内容 */}
  13.         </nav>
  14.         <main id="main-content" tabIndex={-1}>
  15.           {children}
  16.         </main>
  17.         <footer aria-label="Site footer">
  18.           {/* 页脚内容 */}
  19.         </footer>
  20.       </body>
  21.     </html>
  22.   );
  23. }
  25. // app/products/[slug]/page.js
  26. export async function generateMetadata({ params }) {
  27.   const product = await getProduct(params.slug);
  28.   
  29.   return {
  30.     title: `${product.name} - Our Store`,
  31.     description: product.description,
  32.   };
  33. }
  35. export default function ProductPage({ params }) {
  36.   const product = await getProduct(params.slug);
  37.   
  38.   return (
  39.     <div>
  40.       <nav aria-label="Breadcrumb">
  41.         <ol>
  42.           <li><a href="/">Home</a></li>
  43.           <li><a href="/products">Products</a></li>
  44.           <li><a href={`/products/${product.category}`}>{product.category}</a></li>
  45.           <li>{product.name}</li>
  46.         </ol>
  47.       </nav>
  48.       
  49.       <h1>{product.name}</h1>
  50.       {/* 产品内容 */}
  51.     </div>
  52.   );
  53. }
复制代码

总结与展望

Next.js 的路由系统已经从简单的文件系统路由发展成为功能强大且灵活的框架，能够满足现代 Web 应用的复杂需求。通过本文的探索，我们了解了 Next.js 路由的基础原理、高级配置和最佳实践。

从基础的静态和动态路由，到高级的并行路由、拦截路由和条件路由，Next.js 提供了丰富的工具来构建定制化的路由解决方案。结合中间件、性能优化技术和安全最佳实践，我们可以创建出既强大又可靠的 Web 应用。

随着 Next.js 的不断发展，我们可以期待更多创新的路由功能和改进。React Server Components、Suspense 和 Streaming SSR 等技术将继续塑造 Next.js 路由的未来，为开发者提供更强大的工具来构建下一代 Web 应用。

通过掌握 Next.js 路由配置的艺术，开发者可以充分发挥框架的潜力，创建出用户体验优秀、性能卓越且易于维护的现代化 Web 应用。
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则