Hapi 的错误处理机制详解，解决应用出错问题-JavaScript中文网-JavaScript教程资源分享门户

在前端应用程序中，错误处理非常重要，因为它可以帮助我们及时定位和解决问题，提高应用程序的稳定性和可靠性。Hapi 是一个流行的 Node.js Web 应用框架，它提供了一种灵活的错误处理机制，可以帮助我们快速解决应用程序中的错误问题。本文将详细介绍 Hapi 的错误处理机制，包括常见错误类型、错误处理方式以及示例代码。

Hapi 的常见错误类型

在 Hapi 应用程序中，常见的错误类型包括以下几种：

404 错误：表示请求的资源不存在或无法找到。
500 错误：表示服务器出现了内部错误，无法处理请求。
400 错误：表示客户端请求无效或不合法。
401 错误：表示未经授权的请求，需要用户登录或提供有效的凭据。
403 错误：表示请求被拒绝，因为用户没有足够的权限或访问被禁止。

这些错误类型在 Hapi 中都有对应的处理方式，我们可以根据实际情况进行选择。

Hapi 的错误处理方式

Hapi 提供了多种错误处理方式，包括全局错误处理、路由级别错误处理、插件级别错误处理以及请求处理函数级别错误处理。下面分别介绍这些错误处理方式的具体实现。

全局错误处理

全局错误处理是指在应用程序的任何地方都能够捕获和处理错误。可以通过 server.ext() 方法来实现全局错误处理，代码示例如下：

// www.javascriptcn.com code example
server.ext('onPreResponse', (request, h) => {
  const response = request.response;
  if (response.isBoom) {
    return h.view('error', {
      title: 'Error',
      message: response.message,
      statusCode: response.output.statusCode
    }).code(response.output.statusCode);
  }
  return h.continue;
});

上面的代码中，我们使用 onPreResponse 事件来捕获错误。如果响应对象是一个 Boom 错误对象，我们就可以将其转换成一个视图响应，显示错误信息。这种错误处理方式可以帮助我们快速捕获和处理错误，避免错误信息泄露，提高应用程序的安全性和可靠性。

路由级别错误处理

路由级别错误处理是指在特定的路由中捕获和处理错误。可以通过 handler 配置项中的 failAction 选项来实现路由级别错误处理，代码示例如下：

// www.javascriptcn.com code example
{
  method: 'GET',
  path: '/user/{id}',
  handler: (request, h) => {
    const id = request.params.id;
    const user = users.find(user => user.id === id);
    if (!user) {
      return h.response('User not found').code(404);
    }
    return h.response(user);
  },
  options: {
    validate: {
      params: Joi.object({
        id: Joi.string().required()
      })
    },
    failAction: async (request, h, err) => {
      throw Boom.notFound('User not found');
    }
  }
}

上面的代码中，我们使用 failAction 选项来捕获路由中的错误。如果请求参数验证失败或用户不存在，我们就可以返回一个 Boom.notFound 错误对象，让 Hapi 框架自动处理错误。这种错误处理方式可以帮助我们简化代码逻辑，提高代码可读性和可维护性。

插件级别错误处理

插件级别错误处理是指在特定的插件中捕获和处理错误。可以通过插件的 register 方法中的 failAction 选项来实现插件级别错误处理，代码示例如下：

// www.javascriptcn.com code example
exports.plugin = {
  name: 'my-plugin',
  register: (server, options) => {
    server.route({
      method: 'GET',
      path: '/',
      handler: (request, h) => {
        throw new Error('Something went wrong');
      },
      options: {
        plugins: {
          'hapi-swagger': {
            payloadType: 'form'
          }
        },
        failAction: async (request, h, err) => {
          throw Boom.badRequest(err.message);
        }
      }
    });
  }
};

上面的代码中，我们使用 failAction 选项来捕获插件中的错误。如果处理请求时出现错误，我们就可以返回一个 Boom.badRequest 错误对象，让 Hapi 框架自动处理错误。这种错误处理方式可以帮助我们在插件中定义自己的错误处理逻辑，提高代码的可复用性和可扩展性。

请求处理函数级别错误处理

请求处理函数级别错误处理是指在特定的请求处理函数中捕获和处理错误。可以通过请求处理函数中的 try-catch 语句来实现请求处理函数级别错误处理，代码示例如下：

// www.javascriptcn.com code example
{
  method: 'POST',
  path: '/user',
  handler: async (request, h) => {
    try {
      const user = await createUser(request.payload);
      return h.response(user).code(201);
    } catch (err) {
      throw Boom.badRequest(err.message);
    }
  },
  options: {
    validate: {
      payload: Joi.object({
        name: Joi.string().required(),
        email: Joi.string().email().required()
      })
    }
  }
}

上面的代码中，我们使用 try-catch 语句来捕获请求处理函数中的错误。如果创建用户时出现错误，我们就可以返回一个 Boom.badRequest 错误对象，让 Hapi 框架自动处理错误。这种错误处理方式可以帮助我们精细化地控制错误处理逻辑，避免错误信息泄露，提高应用程序的安全性和可靠性。

示例代码

最后，我们给出一个完整的 Hapi 应用程序示例，其中包含了全局错误处理、路由级别错误处理、插件级别错误处理和请求处理函数级别错误处理。代码示例如下：

// www.javascriptcn.com code example
const Hapi = require('@hapi/hapi');
const Joi = require('joi');
const Boom = require('@hapi/boom');

const users = [
  { id: '1', name: 'Alice', email: 'alice@example.com' },
  { id: '2', name: 'Bob', email: 'bob@example.com' },
  { id: '3', name: 'Charlie', email: 'charlie@example.com' }
];

const init = async () => {
  const server = Hapi.server({
    port: 3000,
    host: 'localhost'
  });

  server.route({
    method: 'GET',
    path: '/user/{id}',
    handler: (request, h) => {
      const id = request.params.id;
      const user = users.find(user => user.id === id);
      if (!user) {
        return h.response('User not found').code(404);
      }
      return h.response(user);
    },
    options: {
      validate: {
        params: Joi.object({
          id: Joi.string().required()
        })
      },
      failAction: async (request, h, err) => {
        throw Boom.notFound('User not found');
      }
    }
  });

  server.route({
    method: 'POST',
    path: '/user',
    handler: async (request, h) => {
      try {
        const user = await createUser(request.payload);
        return h.response(user).code(201);
      } catch (err) {
        throw Boom.badRequest(err.message);
      }
    },
    options: {
      validate: {
        payload: Joi.object({
          name: Joi.string().required(),
          email: Joi.string().email().required()
        })
      }
    }
  });

  server.ext('onPreResponse', (request, h) => {
    const response = request.response;
    if (response.isBoom) {
      return h.view('error', {
        title: 'Error',
        message: response.message,
        statusCode: response.output.statusCode
      }).code(response.output.statusCode);
    }
    return h.continue;
  });

  await server.start();
  console.log(`Server running on ${server.info.uri}`);
};

const createUser = async (payload) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const user = { id: '4', ...payload };
      users.push(user);
      resolve(user);
    }, 1000);
  });
};

process.on('unhandledRejection', (err) => {
  console.log(err);
  process.exit(1);
});

init();

在这个示例程序中，我们定义了两个路由：一个用于获取用户信息，一个用于创建用户信息。我们还定义了一个 createUser() 函数，模拟异步创建用户的过程。在全局错误处理中，我们使用 onPreResponse 事件来捕获错误，并将其转换成一个视图响应。在路由级别错误处理中，我们使用 failAction 选项来捕获路由中的错误，并返回一个 Boom.notFound 错误对象。在请求处理函数级别错误处理中，我们使用 try-catch 语句来捕获请求处理函数中的错误，并返回一个 Boom.badRequest 错误对象。

通过这个示例程序，我们可以更加深入地了解 Hapi 的错误处理机制，掌握如何在应用程序中处理错误，提高应用程序的稳定性和可靠性。

来源：JavaScript中文网，转载请注明来源 https://www.javascriptcn.com/post/67d9157ea941bf713408ed43

Hapi 的错误处理机制详解，解决应用出错问题