使用 Fastify 框架实现代码分层架构的最佳实践-JavaScript中文网-JavaScript教程资源分享门户

引言

对于前端开发，我们常常需要构建可维护、可扩展的应用程序。实现代码分层架构是一种有效的解决方案。代码分层框架有多种工具和框架可供选择。其中 Fastify 是一种流行的 Node.js Web 框架，它提供了一些强大且易于使用的功能，使得实现代码分层架构变得更加简单。在本文中，我们将介绍如何使用 Fastify 框架实现代码分层架构的最佳实践。

什么是代码分层架构？

代码分层架构是一种设计模式，用于将应用程序的代码分成独立的、互相关联的层。它是一种模块化的架构，有助于保持代码的可读性和可维护性。通常，代码分层架构将应用程序分成以下层：

Presentation Layer：负责向用户显示数据、响应用户的操作。
Business Layer：负责处理业务逻辑。
Data Access Layer：负责处理与数据相关的查询。

Fastify 框架介绍

Fastify 是一个高效、低开销的 Web 框架，用于构建 Node.js 应用程序。它的主要优点是速度和性能。Fastify 采用了类似 Express 的中间件设计，但它比 Express 更快、更可靠。Fastify 还提供了一些可以使您的工作更加轻松的功能，比如：

路由支持：Fastify 的路由功能非常强大，可以处理所有类型的路由。您可以使用命名参数、通配符、正则表达式等。
插件机制：Fastify 的插件机制允许开发人员在应用程序中使用不同的插件，从而使应用程序更加灵活和可扩展。
验证和输入参数校验：Fastify 提供了一些专门用于验证请求参数的工具，可以帮助您确保输入的数据格式正确，从而减少错误。

除了以上这些功能之外，Fastify 还提供了一些其他有用的工具，使得开发人员可以更轻松地构建高性能的 Web 应用程序。

Fastify 框架的最佳实践

使用 Fastify 框架实现代码分层架构有很多的好处。它可以使代码更加模块化，从而提高代码的可读性和可维护性。下面是一些 Fastify 框架的最佳实践：

使用路由

路由是 Web 应用程序的重要组成部分，它决定了如何将来自客户端的请求映射到服务器上的代码。在 Fastify 中，路由是通过使用 HTTP 方法和 URL 路径来定义的。

const fastify = require('fastify')()
fastify.get('/', async (req, res) => {
  return { message: 'Hello World' }
})
fastify.listen(3000)

它可以简写成：

const fastify = require('fastify')()
fastify.get('/', async (request, reply) => {
  return { hello: 'world' }
})

分层架构

为了将代码分成独立的、互相关联的层，我们可以根据不同的职责分成不同的文件夹，例如：

src/
├── controllers/
├── models/
├── routes/
└── services/

在 controllers 目录中，我们可以定义处理请求的函数。
在 models 目录中，我们可以定义数据模型和与数据库的交互。
在 routes 目录中，我们可以定义处理路由的函数。
在 services 目录中，我们可以定义业务逻辑和服务逻辑。

使用插件

Fastify 框架提供了插件机制，允许开发人员在应用程序中使用不同的插件，从而使应用程序更灵活和可扩展。使用插件可以将功能分成独立的部分，并将其分配给不同的团队或个人进行开发和维护。

使用日志

使用日志是一种跟踪和验证 Web 应用程序的有效方式。Fastify 框架提供了一个名为 pino 的插件，用于记录 Web 应用程序的所有操作。

const fastify = require('fastify')()
fastify.register(require('fastify-pino'), { level: 'info' })
fastify.get('/', (request, reply) => {
  request.log.info('Hello!')
  reply.send({ message: 'Hello World' })
})

当我们执行以上代码时，Fastify 框架将自动将所有日志输出到控制台。

使用 Swagger UI 和 OpenAPI 3.0

Swagger UI 是一种用于构建、测试、记录和共享 API 的框架。 Fastify 框架通过 fastify-swagger 插件支持 Swagger UI。OpenAPI 3.0 是一种规范，用于描述 REST API。

// javascriptcn.com 代码示例
const fastify = require('fastify')()
fastify.register(require('fastify-swagger'), {
  exposeRoute: true,
  routePrefix: '/documentation',
  swagger: {
    info: {
      title: 'Sample API',
      description: 'API description in Markdown.',
      version: '0.1.0'
    },
    servers: [{ url: 'http://localhost:3000', description: 'Development server' }],
    consumes: ['application/json'],
    produces: ['application/json'],
    tags: [{
      name: 'User',
      description: 'API for managing user'
    }]
  }
})

使用单元测试

单元测试是一种评估代码是否符合预期行为的方法。Fastify 框架支持使用 fastify-test-helper、tap 和 jest 等测试框架进行单元测试。可以使用 supertest 包模拟 http 请求并对返回结果进行测试。

const fastify = require('fastify')()
fastify.get('/hello', async (request, reply) => {
  reply.code(200).send({ hello: 'world' })
})

const request = require('supertest')(fastify.server)
test('GET /hello', async t => {
  const response = await request.get('/hello')
  t.is(response.status, 200)
  t.deepEqual(response.body, { hello: 'world' })
})

示例代码

下面是一个简单的 Fastify 应用程序，它实现了代码分层架构的最佳实践。它将应用程序分成 controllers、models、routes 和 services 四个文件夹。我们还将 fastify-auth 和 fastify-mongodb 插件添加到了应用程序中。

// javascriptcn.com 代码示例
const fastify = require('fastify')({
  logger: true
})
const Controller = require('./controllers/controller')
const Routes = require('./routes/routes')
const Service = require('./services/service')

fastify.decorate('service', Service)
fastify.register(require('fastify-auth'), { secret: process.env.SECRET_KEY })
fastify.register(require('fastify-mongodb'), {
  url: 'mongodb://localhost:27017/mydb'
})

fastify.register(Routes, { prefix: '/api' })

const start = async () => {
  try {
    await fastify.listen(3000)
  } catch (err) {
    fastify.log.error(err)
    process.exit(1)
  }
}
start()

Controllers

// javascriptcn.com 代码示例
const {
  OK,
  CREATED,
  BAD_REQUEST,
  NOT_FOUND,
  UNAUTHORIZED
} = require('http-status-codes')

class Controller {
  constructor (service) {
    this.service = service
  }

  async post (request, reply) {
    const { username, password } = request.body
    if (!username || !password) {
      reply.status(BAD_REQUEST).send({
        message: 'Missing username or password'
      })
      return
    }
    const user = await this.service.createUser(username, password)
    if (!user) {
      reply.status(BAD_REQUEST).send({ message: 'User already exists' })
      return
    }
    reply.status(CREATED).send({ user })
  }

  async getAll (request, reply) {
    const users = await this.service.getAll()
    reply.status(OK).send({ users })
  }

  async getById (request, reply) {
    const user = await this.service.getById(request.params.id)
    if (!user) {
      reply.status(NOT_FOUND).send({ message: 'User not found' })
      return
    }
    reply.status(OK).send({ user })
  }

  async deleteById (request, reply) {
    const userToDelete = await this.service.getById(request.params.id)
    if (!userToDelete) {
      reply.status(NOT_FOUND).send({ message: 'User not found' })
      return
    }

    const currentUser = request.user
    if (currentUser.id !== userToDelete.id) {
      reply.status(UNAUTHORIZED).send({ message: 'Unauthorized' })
      return
    }

    const user = await this.service.deleteById(request.params.id)
    if (!user) {
      reply.status(NOT_FOUND).send({ message: 'User not found' })
      return
    }
    reply.status(OK).send({ message: 'User deleted' })
  }
}

module.exports = Controller

Models

// javascriptcn.com 代码示例
const mongoose = require('mongoose')

const schema = new mongoose.Schema({
  username: {
    type: String,
    unique: true,
    required: true
  },
  password: {
    type: String,
    required: true
  }
})

module.exports = mongoose.model('User', schema)

Routes

// javascriptcn.com 代码示例
const Controller = require('../controllers/controller')
const User = require('../models/user')
const fp = require('fastify-plugin')

async function routes (fastify, options) {
  const controller = new Controller(fastify.service)

  fastify.addSchema({
    $id: 'user',
    type: 'object',
    properties: {
      username: { type: 'string' }
    }
  })

  fastify.route({
    method: 'POST',
    url: '/users',
    schema: {
      body: {
        type: 'object',
        properties: {
          username: { type: 'string', minLength: 1 },
          password: { type: 'string', minLength: 1 }
        },
        required: ['username', 'password']
      }
    },
    handler: controller.post,
    preHandler: [fastify.authenticate]
  })

  fastify.route({
    method: 'GET',
    url: '/users',
    schema: {
      response: {
        200: {
          type: 'object',
          properties: {
            users: {
              type: 'array',
              items: { $ref: 'user#' }
            }
          }
        }
      }
    },
    handler: controller.getAll
  })

  fastify.route({
    method: 'GET',
    url: '/users/:id',
    schema: {
      params: {
        type: 'object',
        required: ['id'],
        properties: {
          id: { type: 'string' }
        }
      },
      response: {
        200: {
          type: 'object',
          properties: {
            user: { $ref: 'user#' }
          }
        },
        404: {
          type: 'object',
          properties: {
            message: { type: 'string' }
          }
        }
      }
    },
    handler: controller.getById
  })

  fastify.route({
    method: 'DELETE',
    url: '/users/:id',
    schema: {
      params: {
        type: 'object',
        required: ['id'],
        properties: {
          id: { type: 'string' }
        }
      },
      response: {
        200: {
          type: 'object',
          properties: {
            message: { type: 'string' }
          }
        },
        404: {
          type: 'object',
          properties: {
            message: { type: 'string' }
          }
        },
        401: {
          type: 'object',
          properties: {
            message: { type: 'string' }
          }
        }
      }
    },
    handler: controller.deleteById,
    preHandler: [fastify.authenticate]
  })
}

module.exports = fp(routes)

Services

// javascriptcn.com 代码示例
const User = require('../models/user')

class Service {
  constructor () {
    this.User = User
  }

  async createUser (username, password) {
    const user = await this.User.findOne({ username })
    if (user) {
      return null
    }
    return await this.User.create({ username, password })
  }

  async getAll () {
    return await this.User.find()
  }

  async getById (id) {
    return await this.User.findById(id)
  }

  async deleteById (id) {
    return await this.User.findByIdAndDelete(id)
  }
}

module.exports = Service

总结

本文介绍了使用 Fastify 框架实现代码分层架构的最佳实践，并提供了示例代码。应用代码分层架构的最佳实践可以使代码更加模块化，从而提高代码的可读性和可维护性。Fastify 框架提供了强大的功能和插件机制，可以使开发人员更加轻松地实现这种分层结构。

来源：JavaScript中文网，转载请注明来源本文地址：https://www.javascriptcn.com/post/6520527395b1f8cacd7cf625