Skip to content

4. 路由

4.1. 示例 17:路由器

[React] 应用是一个单页应用:浏览器只加载一个 HTML 页面。点击内部链接时,不会向服务器发送请求:路由器 会改变浏览器显示的地址,并替换显示的组件。[React] 本身没有路由器:我们改用使用最广泛的 [React Router] 库([react-router] 包)。

[React Router] 有三种使用方式(它的“模式”):声明式(使用 [<Routes>] 和 [<Route>] 组件,最简单)、“数据”模式(路由由对象描述,并带有在渲染之前执行的函数:[loader]、[middleware]……),以及“框架”模式(带服务器端渲染的完整应用,类似 [Next.js])。我们使用 数据模式,它提供了我们需要的导航控制。

4.1.1. 数据

// “写死”的数据,使本示例不依赖服务器
export interface Doctor {
  id: number;
  title: string;
  firstName: string;
  lastName: string;
  specialty: string;
}

export const DOCTORS: Doctor[] = [
  { id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner' },
  { id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician' },
  { id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner' },
];

“写死”的数据,使本示例不依赖服务器。

4.1.2. 路由

// =========================================================================
// 17-router/src/routes.tsx - 应用的路由
// -------------------------------------------------------------------------
// React 应用是一个单页应用(SPA:Single
// Page Application):浏览器只加载一个 HTML 页面。点击
// 内部链接时,不会向服务器发送请求:
// 路由器改变浏览器显示的地址,并替换
// 显示在 <Outlet /> 中的组件。
//
// React 没有路由器:我们使用 React Router 库。
// 路由把一个路径与一个组件(一个“页面”)关联起来:
//   'doctors/:id'   :id 是一个参数(/doctors/2 -> id = "2");
//   '*'             任何路径:即“页面未找到”页面(路由器
//                   总是选择最具体的路由)。
// 路由是嵌套的:根路由显示应用的外壳
// (Shell),它的子路由显示在其内部,位于
// 它的 <Outlet /> 所在的位置。
// =========================================================================

import { redirect, type RouteObject } from 'react-router';
import Shell from './Shell';
import Home from './pages/Home';
import DoctorList from './pages/DoctorList';
import DoctorDetail from './pages/DoctorDetail';
import Search from './pages/Search';
import NotFoundPage from './pages/NotFoundPage';

export const routes: RouteObject[] = [
  {
    path: '/',
    Component: Shell,
    children: [
      // index:父路由地址本身(“/”)的路由
      { index: true, Component: Home },
      { path: 'doctors', Component: DoctorList },
      { path: 'doctors/:id', Component: DoctorDetail },
      { path: 'search', Component: Search },
      // 延迟加载:这个页面的代码只在第一次访问时下载
      // (Vite 会为它生成单独的文件)
      { path: 'about', lazy: async () => ({ Component: (await import('./pages/About')).default }) },
      // 重定向:旧地址指向新地址。LOADER
      // 是路由器在显示路由之前调用的函数;
      // 如果它抛出一个重定向,导航的目标就会改变
      {
        path: 'physicians',
        loader: () => {
          throw redirect('/doctors');
        },
      },
      { path: '*', Component: NotFoundPage },
    ],
  },
];
  • 第 20 行:[RouteObject] 是路由的类型;[redirect] 创建一个重定向;
  • 第 28–53 行:路由是 对象:一个路径([path])和一个组件([Component],首字母大写——我们指定的是组件本身,而不是 [<Home />]);
  • 第 30–32 行:路由是 嵌套的:根路由显示应用的“外壳”([Shell]),它的子路由([children])显示在外壳内部,即其 [<Outlet />] 所在的位置。子路由的路径相对于父路由的路径;
  • 第 34 行:一个 index 路由:即父路由地址本身(“/”)的路由;
  • 第 36 行:[:id] 是一个 参数:[/doctors/2] 显示 [DoctorDetail],其中 [id] = “2”;
  • 第 40 行:延迟加载:函数 [lazy] 只在第一次访问该页面时调用。[import('./pages/About')] (一个“动态”导入,写成函数形式)随后下载该模块,[Vite] 已把它存放在单独的文件中。[lazy] 返回路由缺失的属性:这里就是它的组件,该组件由模块默认导出;
  • 第 45–49 行:重定向:旧地址指向新地址。loader 是路由器在显示路由之前调用的函数(用于加载其数据);如果它触发([throw])一个重定向,导航的目标就会改变;
  • 第 50 行:[*] 匹配任何路径:即“页面未找到”页面。路由器总是选择最 具体的路由:路由的顺序无关紧要。

4.1.3. 启动

// =========================================================================
// 17-router/src/main.tsx
// -------------------------------------------------------------------------
// createBrowserRouter(routes) 构建路由器,它跟踪浏览器的
// 地址;<RouterProvider> 显示与当前
// 地址匹配的路由。根组件不再是 App:而是各路由。
// =========================================================================

import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import { createBrowserRouter } from 'react-router';
import { RouterProvider } from 'react-router/dom';
import 'bootstrap/dist/css/bootstrap.min.css';
import { routes } from './routes';

const router = createBrowserRouter(routes);

createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <RouterProvider router={router} />
  </StrictMode>,
);
  • 第 16 行:由各路由构建的路由器。[Browser]:它通过 [history] API 跟踪浏览器的地址;
  • 第 20 行:显示与当前地址对应的路由的组件。根组件不再是 [App]:而是各路由。[RouterProvider] 从 [react-router/dom] 导入,这是该库中专属于浏览器的部分。

4.1.4. 应用外壳

// =========================================================================
// 17-router/src/Shell.tsx - 应用的“外壳”
// -------------------------------------------------------------------------
//   - <Link to="...">、<NavLink to="...">:内部链接。它生成
//     真正的 <a href>,但点击它不会重新加载页面:由路由器
//     处理。NavLink 还知道它是否指向当前显示的页面:
//     如果是,它就添加 “active” 类(与 Bootstrap 的相同);
//   - <Outlet />:显示当前子路由的占位位置;
//   - useLocation():当前地址(pathname、search……)。
// =========================================================================

import { NavLink, Outlet, useLocation } from 'react-router';

export default function Shell() {
  const location = useLocation();
  // decodeURIComponent:%20 重新变回空格
  const address = decodeURIComponent(location.pathname + location.search);

  return (
    <div className="container py-4">
      <h1 className="h3 mb-3">Example 17 - the router</h1>
      <nav className="nav nav-pills mb-3">
        {/* end:“/” 只在地址恰好为 “/” 时才是活动的,而在 /doctors 上不是 */}
        <NavLink className="nav-link" to="/" end>Home</NavLink>
        <NavLink className="nav-link" to="/doctors">Doctors</NavLink>
        {/* ? 之后的参数:NavLink 只比较路径 */}
        <NavLink className="nav-link" to="/search?q=general practitioner">Search</NavLink>
        <NavLink className="nav-link" to="/about">About</NavLink>
        <NavLink className="nav-link" to="/physicians">/physicians (redirect)</NavLink>
        <NavLink className="nav-link" to="/unknown-page">Broken link</NavLink>
      </nav>
      <p className="small text-muted">current address: <code>{address}</code></p>
      <div className="card p-3">
        <Outlet />
      </div>
    </div>
  );
}
  • 第 15 行:[useLocation()] 返回当前地址:[pathname] (路径)、[search] (“?”之后的部分)……每次用户导航时,该组件都会被调用;
  • 第 24 行:[<NavLink to="...">] 是内部链接。它生成有效的 [<a href>] (可以在新标签页中打开),但点击它不会重新加载页面:由路由器处理。[NavLink] 还知道它是否指向当前显示的页面:如果是,它就添加类 [active] (与 [Bootstrap] 相同)。[end]:主页“/”只在地址恰好为“/”时才是活动的,而在 [/doctors] 上不是;[<Link>] 是简化版本,没有 active 类;
  • 第 27 行:带参数的地址。[NavLink] 只比较路径:无论查询参数如何,链接始终保持活动;
  • 第 34 行:显示当前子路由的位置。

4.1.5. 页面

主页:

// React 19:写在组件中的 <title> 元素会由 React 放入
// 页面的 <head> 中;只要该
// 组件处于显示状态,它就会改变标签页的标题
export default function Home() {
  return (
    <>
      <title>Home</title>
      <p className="mb-0">
        Welcome. Click on the links: the address of the browser changes, the page is never reloaded (open
        the Network tab of the developer tools to check it). The Back and Forward buttons of the browser
        work, as well as the reloading (F5) of any page.
      </p>
    </>
  );
}
  • 第 7 行:[React] 会把组件中写的任何元素放入页面的 [<head>] 中,只要该组件处于显示状态:于是每个页面都能设置标签页标题(对 [<meta>] 和 [<link>] 也可以这样做)。

医生列表,带有参数化链接:

// 17-router/src/pages/DoctorList.tsx - 带参数的链接
import { Link } from 'react-router';
import { DOCTORS } from '../data';

export default function DoctorList() {
  return (
    <>
      <title>Doctors</title>
      <ul className="mb-0">
        {DOCTORS.map((m) => (
          // 用字符串模板构建地址 /doctors/2
          <li key={m.id}>
            <Link to={`/doctors/${m.id}`}>{m.title} {m.firstName} {m.lastName}</Link>
          </li>
        ))}
      </ul>
    </>
  );
}

用字符串模板生成地址 [/doctors/2]。

医生的资料页:

// =========================================================================
// 17-router/src/pages/DoctorDetail.tsx - 带参数的页面
// -------------------------------------------------------------------------
// useParams():路径的参数,这里是 { id: "2" } - 始终是
// 字符串。useNavigate():一个用于通过代码导航的函数;
// navigate(-1) 返回上一页,就像“后退”按钮。
// 如果从 /doctors/1 转到 /doctors/2,React 会复用同一个
// 组件:只是用另一个 id 再次调用它。
// =========================================================================

import { useNavigate, useParams } from 'react-router';
import { DOCTORS } from '../data';

export default function DoctorDetail() {
  const { id } = useParams();
  const navigate = useNavigate();
  const doctor = DOCTORS.find((m) => m.id === Number(id));

  if (!doctor) {
    return <p className="text-danger mb-0">Doctor no. {id} does not exist.</p>;
  }

  const next = (doctor.id % DOCTORS.length) + 1;
  return (
    <>
      <title>{`${doctor.firstName} ${doctor.lastName}`}</title>
      <h2 className="h5">{doctor.title} {doctor.firstName} {doctor.lastName}</h2>
      <p>Specialty: {doctor.specialty}</p>
      <div className="d-flex gap-2">
        <button className="btn btn-sm btn-outline-secondary" onClick={() => navigate(-1)}>Back</button>
        <button className="btn btn-sm btn-outline-primary" onClick={() => navigate(`/doctors/${next}`)}>Next doctor</button>
      </div>
    </>
  );
}
  • 第 15 行:[useParams()] 提供路径参数——这里是 [{ id: "2" }]——始终是 字符串格式;
  • 第 16 行:一个用于 通过代码导航的函数;
  • 第 19–21 行:未知的医生([/doctors/9]):显示一条消息;
  • 第 26 行:计算得出的标题:[<title>] 只接受一个字符串,因此使用模板;
  • 第 30 行:[navigate(-1)] 返回上一页,就像浏览器的“后退”按钮;
  • 第 31 行:导航到某个地址。从 [/doctors/1] 到 [/doctors/2] 不会重新创建组件:[React] 只是用不同的 [id] 重新加载它。

搜索:

// =========================================================================
// 17-router/src/pages/Search.tsx - 由 URL 驱动的页面
// -------------------------------------------------------------------------
// /search?q=pediatrician:与 NestJS 课程中的 GET 表单一样,
// 页面完全由它的地址描述:可以加入书签、
// 重新加载、后退。useSearchParams() 给出 ? 之后的
// 参数。
// <Form>(来自 React Router)是一个 GET 表单……而且不会重新加载:
// 路由器导航到 /search?q=<input>。页面显示
// URL 所说的内容,仅此而已。
// =========================================================================

import { Form, useSearchParams } from 'react-router';
import { DOCTORS } from '../data';

export default function Search() {
  const [params] = useSearchParams();
  const q = params.get('q') ?? ''; // 如果不存在则为 null
  const results = DOCTORS.filter((m) => `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(q.toLowerCase()));

  return (
    <>
      <title>Search</title>
      <Form className="d-flex gap-2 mb-3" action="/search">
        {/* 一个非受控字段,以 URL 中的值作为初始值;
            key={q}: if the URL changes (Back button), React recreates the
            field, which then takes the new value of the URL */}
        <input key={q} name="q" className="form-control" placeholder="name or specialty" defaultValue={q} />
        <button className="btn btn-primary">Search</button>
      </Form>
      <ul className="mb-0">
        {results.map((m) => (
          <li key={m.id}>{m.firstName} {m.lastName} ({m.specialty})</li>
        ))}
        {results.length === 0 && <li className="text-muted">No result.</li>}
      </ul>
    </>
  );
}
  • 第 17 行:“?”之后的参数,以 [URLSearchParams] 对象的形式给出:[params.get('q')] 等于 [null] ,当 [q] 不存在时。[useSearchParams] 还(作为第二个元素)返回一个用于修改它们的函数;
  • 第 24 行:[<Form>] (来自 [React Router])是一个 GET 表单……而且不会重新加载页面:提交时,路由器导航到 [/search?q=<input>] ([q] 是字段的 [name])。与 [NestJS] 课程中的 GET 表单一样,页面完全由它的地址描述:你可以把它加入书签、重新加载或后退;
  • 第 28 行:该字段不被验证;它以 URL 中的值作为初始值([defaultValue])。如果 URL 改变而页面没有重新加载(使用“后退”按钮),字段会保留之前的文本;[key={q}] 解决了这个问题。当元素的 key 改变时,[React] 把它当作另一个元素:销毁旧的,创建新的,新元素从新的默认值开始。这是“重置”组件的常用技巧。

按需加载的页面和“页面未找到”页面:

// 17-router/src/pages/About.tsx - 按需加载的页面
// “export default”:路由通过 (await import(...)).default 找到它
export default function About() {
  return (
    <>
      <title>About</title>
      <p className="mb-0">
        This page was downloaded on the first visit (Network tab: a file About-XXXX.js in production).
        Its tab title comes from the title element it contains.
      </p>
    </>
  );
}
import { useLocation } from 'react-router';

export default function NotFoundPage() {
  const { pathname } = useLocation();
  return (
    <>
      <title>Page not found</title>
      <p className="text-danger mb-0">No page at the address <code>{pathname}</code>.</p>
    </>
  );
}

4.1.6. 运行

点击“Doctors”,再点击“Mr Paul TATOU”:地址变为 [/doctors/2],标签页标题变为“Paul TATOU”:

Image

搜索:地址变为 [/search?q=pediatrician]:

Image

“About”:在开发环境中,[About.tsx] 模块只在第一次访问时下载(开发者工具的 Network 选项卡);在生产环境中([npm run build 17-router]),它存放在单独的文件中:

1
2
3
4
17-router/dist/index.html                   0.38 kB │ gzip:   0.26 kB
17-router/dist/assets/index-CqLr8KVv.css  230.06 kB │ gzip:  30.68 kB
17-router/dist/assets/About-DBg63tlb.js     0.36 kB │ gzip:   0.26 kB
17-router/dist/assets/index-evhjxpxc.js   317.05 kB │ gzip: 100.09 kB

Image

“/physicians”会跳转到 [/doctors];一个失效的链接:

Image

你可以重新加载(F5)任何页面:[Vite] 开发服务器对任何未知地址都会返回 [index.html] ,由路由器显示正确的页面。在生产环境中,服务器也需要这样做(见“部署”一章)。

4.2. 示例 18:导航控制

有些页面要求用户已登录或具有特定角色。路由器可以在显示它们之前,通过 中间件来验证这一点。

4.2.1. 会话

// =========================================================================
// 18-guards/src/session.ts - 模拟的会话(没有服务器)
// -------------------------------------------------------------------------
// 已登录的用户必须能被组件(顶部栏、
// 日程页面)和守卫(路由器的函数,它们
// 不是组件,因此无法读取上下文)所知。它存放
// 在一个简单的模块中,一个手工编写的“store”:
//   - 一个私有变量,即状态;
//   - 读取和修改它的函数;
//   - subscribe:状态变化时需要通知的函数列表。
// 组件用 useSyncExternalStore 订阅它(参见 useSession):
// 状态变化时组件会被再次调用。示例 20 将把这项工作交给一个
// 库,即 Zustand。(示例 23 将用真正的
// 服务器完成同样的事情。)
// =========================================================================

import { useSyncExternalStore } from 'react';

export type Role = 'ADMIN' | 'DOCTOR' | 'USER';

export interface User {
  login: string;
  role: Role;
}

// 三个“写死”的账户(密码 = 登录名)
const ACCOUNTS: Record<string, Role> = { admin: 'ADMIN', pelissier: 'DOCTOR', martin: 'USER' };

let user: User | null = null; // 状态
const subscribers = new Set<() => void>();

function setUser(u: User | null) {
  user = u;
  subscribers.forEach((notify) => notify());
}

export const session = {
  user: () => user,
  logIn(login: string, password: string): boolean {
    const role = Object.hasOwn(ACCOUNTS, login) ? ACCOUNTS[login] : undefined;
    if (role === undefined || password !== login) {
      return false;
    }
    setUser({ login, role });
    return true;
  },
  logOut: () => setUser(null),
  subscribe(notify: () => void) {
    subscribers.add(notify);
    return () => subscribers.delete(notify); // 用于取消订阅
  },
};

// 组件使用的 Hook:已登录的用户,始终是最新的
export function useSession(): User | null {
  return useSyncExternalStore(session.subscribe, session.user);
}

已登录的用户必须能被 组件 (顶部栏、日程页面)和 守卫 所知——守卫是路由器的函数,不是组件,因此无法读取上下文。它存放在一个手工编写的简单模块中,即 store ([store]):

  • 第 29–30 行:状态(模块的私有变量),以及状态变化时需要通知的函数列表;
  • 第 32–35 行:修改状态并通知订阅者;
  • 第 37–52 行:公开的函数:读取用户、登录(三个写死的账户,密码 = 登录名)、登出,以及订阅([subscribe] 返回的是用于取消订阅的函数);
  • 第 55–57 行:组件使用的 Hook。[useSyncExternalStore(subscribe, read)] 是 [React] 专为此目的设计的 Hook:它让组件订阅 store,并在读取的值变化时回调组件。

示例 20 将把这项任务交给一个库来完成。

4.2.2. 守卫

// =========================================================================
// 18-guards/src/guards.ts - 导航守卫
// -------------------------------------------------------------------------
// React Router 中间件是路由器在显示声明了它的路由之前
// 调用的函数(middleware: [...]),每次
// 导航到该路由时都会调用。它可以:
//   - 什么都不做:导航继续进行;
//   - 抛出一个重定向 redirect('/address'):
//     导航被替换为前往该地址的导航。
// 它接收导航请求(request.url:请求的地址)。
//
// 这相当于 NestJS 守卫(JwtAuthGuard、
// RolesGuard)在客户端的对应物——但有一个根本的区别:客户端的守卫
// 只是一种便利措施。客户端的代码掌握在用户手中,用户
// 可以随意修改它。数据真正的保护仍然来自
// 服务器(参见关于黑盒的章节)。
// =========================================================================

import { redirect, type MiddlewareFunction } from 'react-router';
import { session, type Role } from './session';

// 请求的地址,不含主机:"/schedule?x=1"
function address(request: Request): string {
  const url = new URL(request.url);
  return url.pathname + url.search;
}

// 该页面要求已登录
export const requireLogin: MiddlewareFunction = ({ request }) => {
  if (session.user() === null) {
    // 未登录:转到登录页面,并记住原本想去的地方
    throw redirect(`/login?redirect=${encodeURIComponent(address(request))}`);
  }
};

// 该页面要求具有给定角色之一:一个构建守卫的函数
export function requireRole(...roles: Role[]): MiddlewareFunction {
  return ({ request }) => {
    const u = session.user();
    if (u === null || !roles.includes(u.role)) {
      // 已登录,但角色不对:返回主页,并附上原因
      throw redirect(`/?denied=${encodeURIComponent(address(request))}`);
    }
  };
}

[React Router] 中间件是路由器在显示声明了它的路由之前调用的函数,每次导航到该路由时都会调用。它可以什么都不做(导航继续进行),也可以触发重定向,以替换当前的导航。

  • 第 23–26 行:它接收导航请求:[request.url] 是完整的请求地址([http://localhost:5173/schedule?x=1]);只保留路径和参数;
  • 第 29–34 行:未登录:重定向到登录页面,同时保留原本想访问的目标([?redirect=...]);
  • 第 37–45 行:一个为给定角色构建守卫的函数;[...roles]:任意数量的参数,被收集成一个数组。已登录但角色不对:重定向到主页,并附上原因。

这相当于 [NestJS] 守卫([JwtAuthGuard]、[RolesGuard])在客户端的对应物,但有一点不同:客户端守卫只是一种 便利措施。客户端代码掌握在用户手中,用户可以随意修改它。真正的数据保护仍然来自服务器(见关于黑盒的章节)。

4.2.3. 受保护的路由

// =========================================================================
// 18-guards/src/routes.tsx - 受保护的路由
// -------------------------------------------------------------------------
// middleware:需要通过的守卫,按顺序执行。按需加载
// (lazy)的页面只有在通过守卫之后才会下载。
// =========================================================================

import { redirect, type RouteObject } from 'react-router';
import Shell from './Shell';
import Home from './pages/Home';
import Login from './pages/Login';
import Schedule from './pages/Schedule';
import { requireLogin, requireRole } from './guards';

export const routes: RouteObject[] = [
  {
    path: '/',
    Component: Shell,
    children: [
      { index: true, Component: Home },
      { path: 'login', Component: Login },
      { path: 'schedule', Component: Schedule, middleware: [requireLogin] },
      {
        path: 'administration',
        middleware: [requireLogin, requireRole('ADMIN')],
        lazy: async () => ({ Component: (await import('./pages/Administration')).default }),
      },
      // 任何其他地址:返回主页
      { path: '*', loader: () => redirect('/') },
    ],
  },
];
  • 第 22 行:路由的保护措施,按顺序执行;
  • 第 24–26 行:按需加载的页面只有在通过守卫之后才会下载;
  • 第 29 行:任何其他地址:返回主页。loader 也可以返回重定向。

启动代码与示例 17 相同:

import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import { createBrowserRouter } from 'react-router';
import { RouterProvider } from 'react-router/dom';
import 'bootstrap/dist/css/bootstrap.min.css';
import { routes } from './routes';

const router = createBrowserRouter(routes);

createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <RouterProvider router={router} />
  </StrictMode>,
);

4.2.4. 外壳与页面

// 18-guards/src/Shell.tsx - 链接,以及已登录的用户
import { NavLink, Outlet, useNavigate } from 'react-router';
import { session, useSession } from './session';

// NavLink 的 className 接受一个函数:它接收 { isActive }
const cssClass = ({ isActive }: { isActive: boolean }) => (isActive ? 'fw-bold' : '');

export default function Shell() {
  const user = useSession();
  const navigate = useNavigate();

  function onLogOut() {
    session.logOut();
    navigate('/');
  }

  return (
    <div className="container py-4" style={{ maxWidth: 720 }}>
      <h1 className="h3 mb-3">Example 18 - navigation guards</h1>
      <nav className="d-flex gap-3 align-items-center mb-3">
        <NavLink to="/" end className={cssClass}>Home</NavLink>
        <NavLink to="/schedule" className={cssClass}>Schedule (logged in)</NavLink>
        <NavLink to="/administration" className={cssClass}>Administration (ADMIN)</NavLink>
        <span className="ms-auto">
          {user ? (
            <>
              {user.login} <span className="badge text-bg-primary">{user.role}</span>
              <button className="btn btn-sm btn-link" onClick={onLogOut}>log out</button>
            </>
          ) : (
            <NavLink to="/login">log in</NavLink>
          )}
        </span>
      </nav>
      <div className="card p-3"><Outlet /></div>
    </div>
  );
}
  • 第 6 行:[NavLink] 的 [className] 可以是一个 函数 ,它接收 [{ isActive }] 作为输入并返回类名;
  • 第 9 行:已登录的用户;顶部栏跟踪其变化;
  • 第 12–15 行:登出并返回主页。
import { useSearchParams } from 'react-router';

export default function Home() {
  // ?denied=...:当角色不符时,由 requireRole 守卫添加
  const denied = useSearchParams()[0].get('denied');
  return (
    <>
      {denied && <p className="alert alert-danger">Your role does not allow you to open {denied}.</p>}
      <p className="mb-0">
        Public page. Try the two other links, logged in or not (admin, pelissier, martin - password = login).
      </p>
    </>
  );
}
import { useSession } from '../session';

export default function Schedule() {
  const user = useSession();
  return (
    <p className="mb-0">
      The schedule of <strong>{user?.login}</strong>: this page requires being logged in.
    </p>
  );
}
1
2
3
4
5
6
7
8
export default function Administration() {
  return (
    <p className="mb-0">
      Administration: page reserved for the ADMIN role, loaded on demand (Network tab: its file is only downloaded
      on the first visit, and only if the guards allowed it).
    </p>
  );
}
// =========================================================================
// 18-guards/src/pages/Login.tsx
// -------------------------------------------------------------------------
// 登录之后,用户会被送回他们原本想打开的页面
// (由守卫添加的参数 ?redirect=...),或者送回主页。
// =========================================================================

import { useState, type FormEvent } from 'react';
import { useNavigate, useSearchParams } from 'react-router';
import { session } from '../session';

export default function Login() {
  const redirection = useSearchParams()[0].get('redirect');
  const navigate = useNavigate();
  const [login, setLogin] = useState('');
  const [password, setPassword] = useState('');
  const [error, setError] = useState(false);

  function submit(e: FormEvent<HTMLFormElement>) {
    e.preventDefault();
    if (!session.logIn(login.trim(), password)) {
      setError(true);
      return;
    }
    // 只接受内部路径:它以 / 开头,但不以 // 开头
    // (//site.com/... 指向另一个站点)- 不会重定向到另一个站点
    const internal = redirection !== null && redirection.startsWith('/') && !redirection.startsWith('//');
    navigate(internal ? redirection : '/');
  }

  return (
    <>
      {redirection && <p className="alert alert-warning">Log in to open {redirection}.</p>}
      <form className="d-flex flex-wrap gap-2" onSubmit={submit}>
        <input className="form-control w-auto" placeholder="login" autoComplete="username" value={login}
               onChange={(e) => setLogin(e.target.value)} />
        <input type="password" className="form-control w-auto" placeholder="password" autoComplete="current-password"
               value={password} onChange={(e) => setPassword(e.target.value)} />
        <button className="btn btn-primary">Log in</button>
      </form>
      {error && <p className="text-danger mt-2 mb-0">Incorrect login or password.</p>}
    </>
  );
}
  • 第 13 行:我们原本想打开的地址,由守卫传递过来;
  • 第 27–28 行:登录之后,我们跳转到那里……前提是它是内部路径(以“/”开头,但不以“//”开头,后者指向另一个站点):一个被恶意构造的登录 URL([/login?redirect=https://malicious-site.com])绝不能把用户带到应用之外。

4.2.5. 运行

在未登录的情况下,点击“Administration”:守卫会重定向到登录页面:

Image

以 [martin] (角色 [USER])登录:角色检查会重定向到主页:

Image

以 [admin] 登录:

Image