Benutzerdefinierte Fehlerbehandlung in einer REST-API mit TypeScript, Express.js, Joi-Validierung und objektorientierter Programmierung

Hallo, Entwickler!

Der Aufbau einer robusten und wartbaren REST-API erfordert sorgfältige Überlegungen zur Fehlerbehandlung, Validierung und Struktur. In diesem Artikel erfahren Sie, wie Sie mithilfe von TypeScript, Express.js, Joi zur Validierung und Prinzipien der objektorientierten Programmierung (OOP) einen benutzerdefinierten Fehlerbehandlungsmechanismus in einer REST-API einrichten. Wir werden unser Projekt wie folgt strukturieren:

Struktur:

---src
-----Middleware
--------ErrorHanlder.ts
-----Modelle
--------User.ts
-----Repository
--------UserRepository.ts
-----Routen
--------UserRouter.ts
-----Controller
--------UserController.ts
-----Dienstleistungen
--------UserService.ts
-----Validierungen
--------UserValidation.ts
---app.ts
---server.ts

Einrichten des Projekts

mkdir rest-api
cd rest-api
npm init -y
npm install express typescript @types/node @types/express ts-node-dev
npx tsc --init

Middleware zur Fehlerbehandlung

// src/middlewares/ErrorHandler.ts
import { Request, Response, NextFunction } from 'express';

class ErrorHandler extends Error {
  statusCode: number;
  message: string;

  constructor(statusCode: number, message: string) {
    super();
    this.statusCode = statusCode;
    this.message = message;
  }
}

const handleError = (err: ErrorHandler, req: Request, res: Response, next: NextFunction) => {
  const { statusCode, message } = err;
  res.status(statusCode).json({
    status: 'error',
    statusCode,
    message,
  });
};

export { ErrorHandler, handleError };

Benutzermodell

// src/models/User.ts
export interface User {
  id: number;
  name: string;
  email: string;
}

Benutzer-Repository

// src/repository/UserRepository.ts
import { User } from '../models/User';

class UserRepository {
  private users: User[] = [];

  findAll(): User[] {
    return this.users;
  }

  findById(id: number): User | undefined {
    return this.users.find(user => user.id === id);
  }

  create(user: User): User {
    this.users.push(user);
    return user;
  }
}

export default new UserRepository();

Benutzerservice

// src/services/UserService.ts
import UserRepository from '../repository/UserRepository';
import { User } from '../models/User';
import { ErrorHandler } from '../middlewares/ErrorHandler';

class UserService {
  getAllUsers(): User[] {
    return UserRepository.findAll();
  }

  getUserById(id: number): User | undefined {
    const user = UserRepository.findById(id);
    if (!user) {
      throw new ErrorHandler(404, 'User not found');
    }
    return user;
  }

  createUser(user: User): User {
    const { error } = userSchema.validate(user);
    if (error) {
      throw new ErrorHandler(400, error.details[0].message);
    }
    return UserRepository.create(user);
  }
}

export default new UserService();

Benutzervalidierung

// src/validations/UserValidation.ts
import Joi from 'joi';

const userSchema = Joi.object({
  id: Joi.number().required(),
  name: Joi.string().required(),
  email: Joi.string().email().required(),
});

export { userSchema };

Benutzercontroller

// src/controllers/UserController.ts
import { Request, Response, NextFunction } from 'express';
import UserService from '../services/UserService';
import { ErrorHandler } from '../middlewares/ErrorHandler';

class UserController {
  getAllUsers(req: Request, res: Response, next: NextFunction) {
    try {
      const users = UserService.getAllUsers();
      res.json(users);
    } catch (error) {
      next(error);
    }
  }

  getUserById(req: Request, res: Response, next: NextFunction) {
    try {
      const user = UserService.getUserById(parseInt(req.params.id));
      res.json(user);
    } catch (error) {
      next(error);
    }
  }

  createUser(req: Request, res: Response, next: NextFunction) {
    try {
      const user = UserService.createUser(req.body);
      res.status(201).json(user);
    } catch (error) {
      next(error);
    }
  }
}

export default new UserController();

Benutzerrouten

// src/routes/UserRouter.ts
import { Router } from 'express';
import UserController from '../controllers/UserController';

const router = Router();

router.get('/users', UserController.getAllUsers);
router.get('/users/:id', UserController.getUserById);
router.post('/users', UserController.createUser);

export default router;

Anwendungseinstiegspunkt

// src/app.ts
import express from 'express';
import UserRouter from './routes/UserRouter';
import { handleError } from './middlewares/ErrorHandler';

const app = express();

app.use(express.json());
app.use('/api', UserRouter);
app.use(handleError);

export default app;

Server-Setup

// src/server.ts
import app from './app';

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Durch die Strukturierung unseres Projekts mithilfe von TypeScript-, Express.js-, Joi- und OOP-Prinzipien erreichen wir eine saubere und wartbare Codebasis. Die benutzerdefinierte Fehlerbehandlungs-Middleware bietet eine konsistente Möglichkeit, Fehler in der gesamten Anwendung zu verwalten, während die Validierungslogik die Datenintegrität gewährleistet. Dieses Setup kann als solide Grundlage für komplexere Anwendungen dienen.

Kontakte
E-Mail: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

Das obige ist der detaillierte Inhalt vonBenutzerdefinierte Fehlerbehandlung in einer REST-API mit TypeScript, Express.js, Joi-Validierung und objektorientierter Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!