NestJS Enterprise Backend APIs · 课时

路由与请求处理

定义 API 路由，处理各种 HTTP 方法，并从请求正文、参数和查询中提取数据。

第 1 / 3 课12 个步骤

路由与请求处理 是 CoddyKit 上的免费 NestJS Enterprise Backend APIs 课时。这是第 1 节课，共 3 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 NestJS Enterprise Backend APIs 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 NestJS Enterprise Backend APIs 课程共包含 3 节课。

本课时的部分内容尚未翻译，以英文显示。

Understanding API Routes

When you build a web API, you need a way for clients (like a browser or mobile app) to send requests to specific functions on your server. This is where routes come in!

A route defines how a client's request URL (like /users or /products/1) maps to a particular action in your application code. It's like a street address for your API's functionalities.

HTTP Methods: The Action Verbs

Besides the URL, every request also uses an HTTP method, which tells the server what kind of action the client wants to perform. Common methods include:

GET: Retrieve data (e.g., get a list of users).
POST: Create new data (e.g., create a new user).
PUT: Update existing data completely.
PATCH: Partially update existing data.
DELETE: Remove data.

NestJS uses decorators like @Get() or @Post() to link these methods to your controller functions.

Your First GET Route

Let's define a simple route to fetch some data. In NestJS, you use controllers to handle incoming requests and define routes.

The @Controller() decorator defines a base path for all routes within that controller. Then, methods like @Get() define specific endpoints and their HTTP methods.

Simple GET Route Example

Here's a basic NestJS app with a /greet endpoint. Run this example, then try accessing http://localhost:3000/greet in your browser or a tool like Postman.

You should see: Hello from NestJS!

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Get } from '@nestjs/common';

@Controller('greet')
class GreetController {
  @Get()
  getGreeting(): string {
    return 'Hello from NestJS!';
  }
}

@Module({
  controllers: [GreetController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Dynamic Routes with Parameters

Often, you need routes that include dynamic data, like fetching a specific user by their ID (e.g., /users/123). These are called path parameters.

In NestJS, you define path parameters using a colon (:) followed by the parameter name in your @Get() decorator (e.g., @Get(':id')). You then extract its value using the @Param() decorator in your method signature.

Path Parameters Example

This example shows how to get a user ID from the URL path. If you run this, then visit http://localhost:3000/users/123, the output will be:

User ID: 123

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Get, Param } from '@nestjs/common';

@Controller('users')
class UsersController {
  @Get(':id')
  findUser(@Param('id') id: string): string {
    return `User ID: ${id}`;
  }
}

@Module({
  controllers: [UsersController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Filtering with Query Parameters

Query parameters are another way to pass data to your routes, often used for optional filtering, sorting, or pagination (e.g., /items?category=books&limit=5).

These parameters appear after a question mark (?) in the URL, as key-value pairs separated by ampersands (&). NestJS lets you easily access them using the @Query() decorator.

Query Parameters Example

This route uses query parameters to filter items. If you run this, then visit http://localhost:3000/items?category=books&limit=5, you'll see:

Category: books, Limit: 5

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Get, Query } from '@nestjs/common';

@Controller('items')
class ItemsController {
  @Get()
  findItems(
    @Query('category') category: string,
    @Query('limit') limit: string,
  ): string {
    return `Category: ${category || 'all'}, Limit: ${limit || '10'}`;
  }
}

@Module({
  controllers: [ItemsController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Handling Request Body (POST/PUT)

For operations that send a lot of data, like creating a new resource (POST) or updating an existing one (PUT), the data is typically sent in the request body.

The request body can contain structured data, often JSON. NestJS provides the @Body() decorator to easily parse and extract this data directly into your controller method's arguments.

Request Body Example (POST)

This example shows how to accept data in the request body for a POST request. If you send a POST request to http://localhost:3000/products with a JSON body like {"name": "Laptop", "price": 1200}, the output will be:

Product created: {"name":"Laptop","price":1200}

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Post, Body } from '@nestjs/common';

interface Product {
  name: string;
  price: number;
}

@Controller('products')
class ProductsController {
  @Post()
  createProduct(@Body() product: Product): string {
    return `Product created: ${JSON.stringify(product)}`;
  }
}

@Module({
  controllers: [ProductsController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Route Handling Check

Consider the following NestJS controller snippet:

import { Controller, Get, Param, Query } from '@nestjs/common';

@Controller('articles')
class ArticlesController {
  @Get(':id')
  getArticleById(@Param('id') id: string): string {
    return `Article ID: ${id}`;
  }

  @Get()
  searchArticles(@Query('keyword') keyword: string): string {
    return `Searching for: ${keyword || 'all articles'}`;
  }
}

Which URL would successfully retrieve an article with ID "123"?

在交互式课程中回答

Recap: Routes & Requests

Great job! You've covered the fundamentals of defining API routes and handling different types of incoming data in NestJS:

Routes map URLs to controller actions.
HTTP methods (GET, POST, PUT, DELETE) define the action type.
Path parameters (@Param()) capture dynamic segments from the URL path.
Query parameters (@Query()) extract optional key-value pairs from the URL string.
Request body (@Body()) handles data sent with POST/PUT requests.

These are crucial building blocks for any robust RESTful API!

免费开始

用 AI 导师学习 TypeScript — 免费

在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。

课程: 20
课程: 76

免费开始学习查看完整课程

常见问题解答

「路由与请求处理」课时是免费的吗？

是的 — 「路由与请求处理」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 NestJS Enterprise Backend APIs 课程的其余内容，请升级到 CoddyKit PRO。 NestJS Enterprise Backend APIs 课程共包含 3 节课。

「路由与请求处理」这节课中我会学到什么？

定义 API 路由，处理各种 HTTP 方法，并从请求正文、参数和查询中提取数据。你通过在浏览器中直接运行的动手代码来练习 NestJS Enterprise Backend APIs，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 NestJS Enterprise Backend APIs 需要有经验吗？

无需任何先前经验。CoddyKit 上的 NestJS Enterprise Backend APIs 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 3 节。

「路由与请求处理」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 NestJS Enterprise Backend APIs 课中编写并运行代码吗？

能。每节 NestJS Enterprise Backend APIs 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 NestJS Enterprise Backend APIs