如何使用Node.js、TypeScript和Express實現RESTful API服務

黄明基發表於2024-06-02

Node.js是一個基於 Chrome V8 引擎的 JavaScript 執行環境。Node.js 使用了一個事件驅動、非阻塞式 I/O 的模型,使其輕量又高效。Express是一個保持最小規模的靈活的 Node.js Web應用程式開發框架,為Web和移動應用程式提供一組強大的功能。使用Node.js和Express可以快速的實現一個RESTful API服務。

什麼是RESTful API

RESTful API是一種遵循 REST（Representational State Transfer，表現層狀態轉移）架構風格的網路 API 設計，它使用HTTP協議定義的請求方法(GET、POST、PUT、DELETE)來定義對資源的操作。
RESTful API是一種非常流行的API設計風格，它具有以下特點：

使用HTTP協議定義對資源的操作
使用HTTP協議定義的請求方法(GET、POST、PUT、DELETE)來定義對資源的操作
使用JSON作為資料交換格式
使用URL來定義資源
使用HTTP狀態碼來表示操作結果

如何使用nodejs和express實現一個RESTful API

在MySQL中建立一個資料庫和表

CREATE DATABASE `app`;

CREATE TABLE if not exists user (
    id BIGINT NOT NULL,
    account  varchar(100) DEFAULT '' NOT NULL,
    password varchar(200) DEFAULT '' NOT NULL,
    secret_key varchar(100) DEFAULT '' NOT NULL,
    nick_name varchar(100) DEFAULT '' NOT NULL,
    avatar varchar(300) DEFAULT '' NOT NULL,
    email varchar(100) DEFAULT '' NOT NULL,
    email_verified tinyint(1) DEFAULT 0 NOT NULL,
    phone_number varchar(100) DEFAULT '' NOT NULL,
    phone_numbert_verified tinyint(1) DEFAULT 0 NOT NULL,
    creator_id BIGINT DEFAULT 0 NOT NULL,
    creation_time timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL,
    last_modifier_id BIGINT DEFAULT 0 NOT NULL,
    last_modification_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
    CONSTRAINT pk_user PRIMARY KEY (id),
    CONSTRAINT unique_user_email UNIQUE KEY (email),
    CONSTRAINT unique_user_phone UNIQUE KEY (phone_number)
)
ENGINE=InnoDB
DEFAULT CHARSET=utf8mb4
COLLATE=utf8mb4_unicode_ci

從GitHub下載專案模板一個基於nodejs、TypeScript和express的web模板

建立User實體類

class User {
    public id!: bigint;
    public account: string;
    public password: string;
    public secret_key: string
    public nick_name: string;
    public avatar: string;
    public email: string;
    public phone_number: string;
    public creator_id: bigint;
    public creation_time!: Date;
    public last_modifier_id!: bigint;
    public last_modification_time!: Date;

    constructor(account: string, password: string, secret_key: string, nick_name: string, avatar: string, email: string,
        phone_number: string, creator_id: bigint) {
        this.account = account;
        this.password = password;
        this.secret_key = secret_key;
        this.nick_name = nick_name;
        this.avatar = avatar;
        this.email = email;
        this.phone_number = phone_number;
        this.creator_id = creator_id;
    }
}

export default User;

建立UserService類

import User from "../models/User";
import { connection } from '../utils/db';
import PasswordSecurity from '../utils/password-security';
import { SnowflakeId } from "../utils/snowflakeid";

class UserService {

    public async create(user: User): Promise<User> {
        return new Promise<User>((resolve, reject) => {
            try {
                const passwordSecurity = new PasswordSecurity();
                const secret_key = passwordSecurity.createSalt();
                user.id = SnowflakeId.newId();
                user.secret_key = secret_key;
                user.password = passwordSecurity.createHash(user.password, secret_key);
                user.creation_time = new Date();
                user.last_modifier_id = user.creator_id;
                user.last_modification_time = new Date();
                connection.query('insert into user (id, account, password, secret_key, nick_name, avatar, email, phone_number, creator_id, creation_time, last_modifier_id, last_modification_time)'
                    + 'values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
                    [user.id, user.account, user.password, user.secret_key, user.nick_name, user.avatar, user.email, user.phone_number, user.creator_id, user.creation_time, user.last_modifier_id, user.last_modification_time],
                    function (error: any, result: any) {
                        if (error) {
                            console.log('Error: ' + error.message);
                            reject(error);
                        } else {
                            resolve(user);
                        }
                    });
            } catch (e) {
                reject(e)
            }
        })
    }

    public async getByAccount(account: string): Promise<User> {
        return new Promise<User>((resolve, reject) => {
            try {
                connection.query('select * from user where account = ?', [account], function (error: any, result: any) {
                    if (error) {
                        console.log('Error: ' + error.message);
                        reject(error);
                    } else {
                        resolve(result[0]);
                    }
                });
            } catch (e) {
                reject(e)
            }
        })
    }

    public async getById(id: number): Promise<User> {
        return new Promise<User>((resolve, reject) => {
            try {
                connection.query('select * from user where id = ?', [id], function (error: any, result: any) {
                    if (error) {
                        console.log('Error: ' + error.message);
                        reject(error);
                    } else {
                        resolve(result[0]);
                    }
                })
            } catch (e) {
                reject(e)
            }
        });
    }

    public async getByEmail(email: string): Promise<User> {
        return new Promise<User>((resolve, reject) => {
            try {
                connection.query('select * from user where email = ?', [email], function (error: any, result: any) {
                    if (error) {
                        console.log('Error: ' + error.message);
                        reject(error);
                    } else {
                        resolve(result[0]);
                    }
                })
            } catch (e) {
                reject(e)
            }
        })
    }

    public async getByPhoneNumber(phone_number: string): Promise<User> {
        return new Promise<User>((resolve, reject) => {
            try {
                connection.query('select * from user where phone_number = ?', [phone_number], function (error: any, result: any) {
                    if (error) {
                        console.log('Error: ' + error.message);
                        reject(error);
                    } else {
                        resolve(result[0]);
                    }
                })
            } catch (e) {
                reject(e)
            }
        })
    }

    public async update(user: User): Promise<User> {
        return new Promise((resolve, reject) => {
            try {
                connection.query('update user set account = ?, password = ?, secret_key = ?, name = ?, avatar = ?, email = ?, phone_number = ?, creator_id = ?, creation_time = ?, last_modifier_id = ?, last_modification_time = ? where id = ?',
                    [user.account, user.password, user.secret_key, user.nick_name, user.avatar, user.email, user.phone_number, user.last_modifier_id, user.last_modification_time, user.id], function (error, result) {
                        if (error) {
                            console.log('Error: ' + error.message);
                            reject(error)
                        } else {
                            resolve(user);
                        }
                    });
            } catch (e) {
                reject(e);
            }
        });
    }

    public async delete(id: number): Promise<void> {
        return new Promise<void>((resolve, reject) => {
            try {
                connection.query('delete from user where id = ?', [id], function (error, result) {
                    if (error) {
                        console.log('Error: ' + error.message);
                        reject(error)
                    } else {
                        resolve();
                    }
                });
            } catch (e) {
                reject(e);
            }
        })
    }

}

export default new UserService();

建立UserController

import { Request, Response } from 'express';
import User  from '../models/User';
import UserService from '../services/UserService';
import { success, error } from '../utils/json-result'
import { Get, Post, Put, Delete, Controller} from '../utils/routing-controllers'

@Controller('/api/user')
class UserController {

    constructor() { }

    @Post('/')
    public async create(req: Request, res: Response): Promise<any> {
        try {
            var user = new User(
                req.body.name, 
                req.body.password, 
                req.body.secret_key, 
                req.body.nick_name, 
                req.body.avatar == null || req.body.avatar == undefined ? '' : req.body.avatar, 
                req.body.email,
                req.body.phone_number, 
                req.body.creator_id == null || req.body.creator_id == undefined ? 0 : req.body.creator_id);
    
            if (user.account == null || user.account == '') {
                error(res, "使用者名稱不能為空");
                return;
            }
            if (user.password == null || user.password == '') {
                error(res, "密碼不能為空");
                return;
            }
            if (user.email == null || user.email == '') {
                error(res, "郵箱不能為空");
                return;
            }
            if (user.phone_number == null || user.phone_number == '') {
                error(res, "手機號不能為空");
                return;
            }
            var existingUser = await UserService.getByAccount(user.account);
            if (existingUser != null) {
                error(res, "使用者已存在");
                return
            }
            existingUser = await UserService.getByEmail(user.email);
            if (existingUser != null) {
                error(res, "郵箱已存在");
                return;
            }
            existingUser = await UserService.getByPhoneNumber(user.phone_number);
            if (existingUser != null) {
                error(res, "手機號已存在");
                return;
            }
            UserService.create(user).then(result => {
                success(res, result);
            });
        } catch (err: any) {
            console.error(err);
            error(res, err.message);
        }
    }

    @Get('/')
    public get(req: Request, res: Response): any {
        res.send('users');
    }

    @Put('/')
    public update(req: Request, res: Response): any {
        res.send('update user');
        // 處理更新使用者的請求
    }

    @Delete('/')
    public delete(req: Request, res: Response): void {
        res.send('delete user');
        // 處理刪除使用者的請求
    }
}

export default UserController;

啟動服務

npm start

測試

curl -X POST -H "Content-Type: application/json" -d '{"account":"admin","password":"123456","secret_key":"123456","nick_name":"admin","email":"22222@qq.com","phone_number":"13888888888"}' http://localhost:3000/api/user

返回結果

{"account":"admin","password":"43ad945a38257858c962d7e703bf090db019e61efda2edd34a48480e8da51b4a12c1f1d04ed06feced130bfa30e76e41f08762ee7e04fe038b2ecd4b90d43c94","secret_key":"b4689647434328c65a18cb7707b74734","nick_name":"admin","avatar":"","email":"22222@qq.com","phone_number":"13888888888","creator_id":0,"id":"11087864288776192","creation_time":"2024-06-02T14:19:12.888Z","last_modifier_id":0,"last_modification_time":"2024-06-02T14:19:12.888Z"}

使用 Flask 實現 RESTful API
2016-06-14
FlaskRESTAPI
Node.js 配合 express 框架、ejs 、mongodb 實現應用 && [使用 TypeScript 重構]
2019-03-21
Node.jsExpress框架MongoDBTypeScript
RESTFul Web Api 服務框架（一）
2013-11-12
RESTWebAPI框架
如何使用RestTemplate訪問restful服務
2018-04-20
REST
使用Express開發小說API介面服務1.0(二)
2018-06-14
ExpressAPI
使用Express開發小說API介面服務1.0（三）
2018-06-14
ExpressAPI
使用Express開發小說API介面服務1.0（一）
2018-06-12
ExpressAPI
使用SCA和JAX-RS建立RESTful服務
2010-11-12
REST
使用Docker實現Spring Boot Restful Web服務案例原始碼
2019-01-17
DockerSpring BootRESTWeb原始碼
基於 SpringMVC 的 RESTful HTTP API 實踐（服務端）
2017-06-29
SpringMVCRESTHTTPAPI服務端
使用nodejs和express搭建http web服務
2021-01-15
NodeJSExpressHTTPWeb
nodejs實現restful API
2019-02-16
NodeJSRESTAPI
[譯]使用 JavaScript 和網路資訊 API 實現自適應服務
2019-03-01
JavaScriptAPI
DRF使用超連結API實現真正RESTful
2020-12-21
APIREST
使用CXF開發RESTFul服務
2014-11-16
REST
node+express+MongoDB實現小商城服務端
2019-01-19
ExpressMongoDB服務端
頁面錄製服務上線：RESTful API 呼叫實現，所見所錄即所得
2021-11-02
RESTAPI
node.js的express模組實現GET和POST請求
2022-06-14
Node.jsExpress
如何使用華為雲服務一鍵構建部署釋出前端和Node.js服務
2020-08-18
前端Node.js
RESTful API開發實戰使用REST JSON XML和JAX-RS構建微服務大資料和Web服務應用
2018-11-05
RESTAPIJSONXML微服務大資料Web
用 Go 快速開發一個 RESTful API 服務
2022-05-16
GoRESTAPI
Go實戰 21 | 網路程式設計：玩轉 RESTful API 服務
2021-03-19
Go程式設計RESTAPI
使用 Jersey 和 Apache Tomcat 構建 RESTful Web 服務
2014-11-16
ApacheTomcatRESTWeb
搭建node服務（三）：使用TypeScript
2020-07-17
TypeScript
如何使用華為機器學習服務和Kotlin實現語音合成
2020-08-17
機器學習Kotlin
使用TypeScript和nextjs實現基於CQRS的微服務的銀行API原始碼
2022-05-09
TypeScriptNextJS微服務API原始碼
使用Golang和MongoDB構建 RESTful API
2021-09-09
GolangMongoDBRESTAPI
轉享:Ehcache 服務和RESTful Web Services
2010-05-31
RESTWeb
.NET雲原生應用實踐（二）：Sticker微服務RESTful API的實現
2024-10-13
微服務RESTAPI
搭建 Restful Web 服務
2022-03-09
RESTWeb
SpringBoot使用Swagger2實現Restful API
2021-09-09
Spring BootSwaggerRESTAPI
A Simple RESTful API Service With Node.js And Koa2
2017-12-25
RESTAPINode.js
實現一個簡單的 RESTful API
2018-11-02
RESTAPI
InfoQ: 建立RESTful服務，有GET和POST足矣？
2010-06-25
REST
使用JWT做RESTful API的身份驗證-Go語言實現
2018-07-17
JWTRESTAPIGo
Node.js 連線到 Spring Eureka 實現服務發現
2024-06-20
Node.jsSpring
使用node+puppeteer+express搭建截圖服務
2021-01-02
Express
Springboot 實現 Restful 服務，基於 HTTP / JSON 傳輸
2017-02-17
Spring BootRESTHTTPJSON