koa结合koa-router开发nodejs服务
淳于健
koa-service
├─ babel.config.json - Babel配置项
├─ package-lock.json
├─ package.json
├─ README.md
└─ src - 源文件
├─ app - koa实例
│ ├─ conf.js - koa相关配置项
│ └─ index.js - koa入口文件
├─ auth - 权限验证
│ └─ index.js - 权限验证入口文件
├─ controllers - 控制器
│ ├─ common - 公共控制器
│ ├─ index.js - 控制器入口文件
│ ├─ modules - 模块控制器
│ │ ├─ role.js - 角色控制器
│ │ └─ user.js - 用户控制器
│ └─ util.js - 控制器工具
├─ db - 数据库
│ ├─ conf.js - 数据库配置项
│ └─ index.js - 数据库入口文件
├─ index.js - 总入口文件
├─ model - 数据库模型
│ └─ user.js - 用户模型
├─ redis - redis缓存数据库
│ ├─ conf.js - redis相关配置项
│ └─ index.js - redis入口文件
├─ router - router
│ ├─ conf.js - 路由相关配置项
│ └─ index.js - 路由入口文件
├─ services - 服务
│ ├─ baseService.js - 主服务
│ └─ user.js - 用户服务
└─ utils - 项目工具类
└─ index.js - 项目工具类入口文件
1、创建项目，并初始化项目
$ mkdir koa-service
2、初始化项目
$ npm init -y
# 创建babel配置项文件
$ touch babel.config.json
3、创建相关文件
# 创建源文件文件夹src和公共入口文件
$ mkdir src && touch src/index.js
# 将终端中的路径切换到src
$ cd src
# 以下为创建src目录里面的子文件夹和相应的文件
# 创建koa实例文件夹以及相关文件
$ mkdir app && touch app/conf.js app/index.js
# 创建权限验证文件夹以及相关文件
$ mkdir auth && touch auth/index.js
# 创建控制器中间件文件夹以及相关文件
$ mkdir controllers controllers/common controllers/modules && touch controllers/index.js controllers/util.js controllers/modules/role.js controllers/modules/user.js
# 创建数据库文件夹以及相关文件
$ mkdir db && touch db/conf.js db/index.js
# 创建数据库模型文件夹以及相关文件
$ mkdir model && touch model/user.js
# 创建redis文件夹以及相关文件
$ mkdir redis && touch redis/conf.js redis/index.js
# 创建router文件夹以及相关文件
$ mkdir router && touch router/conf.js router/index.js
# 创建services文件夹以及相关文件
$ mkdir services && touch services/baseService.js services/user.js
# 创建utils文件夹以及相关文件
$ mkdir utils && touch utils/index.js
# 将终端中的路径切换回项目根目录
$ cd ..
4、安装项目所需依赖
# 安装外部依赖
$ npm install @babel/polyfill @koa/router koa koa-body pm2 --save
# 安装项目依赖
$ npm install @babel/cli @babel/core @babel/node @babel/plugin-proposal-decorators @babel/preset-env core-js cross-env ioredis mysql2 node-console-colors sequelize --save-dev
5、修改package.json文件
{
"name": "koa-service",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"dev": "cross-env NODE_ENV=development babel-node src/index",
"test": "echo \"Error: no test specified\" && exit 1",
"clear": "rm -rf lib/**",
"babel": "npm run clear && babel src --out-dir lib"
},
"keywords": [],
"author": "",
"license": "ISC",
"dependencies": {
"@babel/polyfill": "^7.12.1",
"@koa/router": "^10.1.1",
"koa": "^2.13.4",
"koa-body": "^4.2.0",
"pm2": "^5.1.2"
},
"devDependencies": {
"@babel/cli": "^7.16.0",
"@babel/core": "^7.16.0",
"@babel/node": "^7.16.0",
"@babel/plugin-proposal-decorators": "^7.16.0",
"@babel/preset-env": "^7.16.0",
"core-js": "^3.19.1",
"cross-env": "^7.0.3",
"ioredis": "^4.28.0",
"mysql2": "^2.3.3-rc.0",
"node-console-colors": "^1.1.4",
"sequelize": "^6.9.0"
}
}
6、修改babel.config.json
{
// "sourceMaps": true,
// "sourceType": "module",
// "compact": true,
// "minified": true,
"presets": [
[
"@babel/preset-env", // 对 targets 目标浏览器中没有的功能添加转换插件
{
"targets": {
// "esmodules": true,
// "node": "v14.14.0",
"edge": "17",
"firefox": "60",
"chrome": "67",
"safari": "11.1"
},
"useBuiltIns": "usage", // usage: 按需加载 polyfill, entry: 加载全部
"corejs": "3.19.1"
}
]
],
"plugins": [
[
"@babel/plugin-proposal-decorators",
{
"legacy": true
}
]
]
}
7、其他相关文件代码
// app/conf.js
import os from 'os';
/**
* port: http\https 服务启动的默认端口
* bodyConfig: koa 正文解析器中间件 koa-body 的配置项
*/
/**
* @description: Koa Config
* @param {number} [port=3000] - 服务启用的默认端口
* @param {object} [bodyConf] - koa-body中间件的配置项（正文解析配置项）
* @param {boolean} [bodyConf.strict=true] - 是否启用严格模式，启用后不会解析 GET, HEAD, DELETE 请求
* @param {array} [bodyConf.parsedMethods=['POST', 'PUT', 'PATCH', 'GET', 'HEAD', 'DELETE']] - 请求方法
* 注意：strict 和 parsedMethods 这两个配置项不能共存
* @param {boolean} [bodyConf.patchNode=false] - 是否将请求体打到原生 node.js 的ctx.req中
* @param {boolean} [bodyConf.patchKoa=true] - 将请求体打到 koa 的 ctx.request 中
* @param {string|number} [bodyConf.jsonLimit='1mb'] - JSON 数据体的大小限制
* @param {string|number} [bodyConf.formLimit='56kb'] - 限制表单请求体的大小
* @param {string|number} [bodyConf.textLimit='56kb'] - 限制 text body 的大小
* @param {string} [bodyConf.encoding='utf-8'] - 表单的默认编码
* @param {boolean} [bodyConf.multipart=false] - 是否支持 multipart-formdate 的表单
* @param {boolean} [bodyConf.urlencoded=true] - 否支持 urlencoded 的表单
* @param {boolean} [bodyConf.text=true] - 是否解析 text/plain 的表单
* @param {boolean} [bodyConf.json=true] - 是否解析 json 请求体
* @param {boolean} [bodyConf.jsonStrict=true] - 是否使用 json 严格模式，true 会只处理数组和对象
* @param {boolean} [bodyConf.includeUnparsed=false] - 是否使用 json 严格模式，true 会只处理数组和对象
* @param {object} [bodyConf.queryString=null] - 请求查询的内容
* @param {object} [bodyConf.formidable={}] - 配置更多的关于 multipart 的选项
* @param {string} [bodyConf.formidable.encoding='utf-8'] - 默认编码
* @param {string} [bodyConf.formidable.uploadDir=(os.tmpdir && os.tmpdir()) || os.tmpDir()] - 设置文件上传目录
* @param {boolean} [bodyConf.formidable.keepExtensions=false] - 是否保留原文件后缀名
* @param {boolean} [bodyConf.formidable.allowEmptyFiles=true] - 是否允许上传空文件
* @param {number} [bodyConf.formidable.minFileSize=1] - 限制上传文件大小的最小值
* @param {number} [bodyConf.formidable.maxFileSize=200 * 1024 * 1024] - 限制上传文件大小的最大值
* @param {number} [bodyConf.formidable.maxFields=1000] - 限制字段的最大个数
* @param {number} [bodyConf.formidable.maxFieldsSize=20 * 1024 * 1024] - 限制字段值的大小的最大值
* @param {string|boolean} [bodyConf.formidable.hash=false] - 是否计算文件的 hash，如果为 true 选择 md5/sha1 进行计算（包括为传入文件计算的校验和，将其设置为某些哈希算法，有关可用算法，请参见crypto.createHash）
* @param {boolean} [bodyConf.formidable.multiples=false] - 是否支持多文件上传
* @param {function} [bodyConf.formidable.onFileBegin=(name, file) => {}] - 文件上传前的回调方法
* @param {boolean|function} [bodyConf.onError=false] - 错误处理方法
*/
const config = {
port: 3000,
bodyConf: {
// strict: true,
// parsedMethods: ['POST', 'PUT', 'PATCH', 'GET', 'HEAD', 'DELETE'],
patchNode: false,
patchKoa: true,
jsonLimit: '1mb',
formLimit: '56kb',
textLimit: '56kb',
encoding: 'utf-8',
multipart: false,
urlencoded: true,
text: true,
json: true,
jsonStrict: true,
includeUnparsed: false,
queryString: null,
formidable: {
encoding: 'utf-8',
uploadDir: (os.tmpdir && os.tmpdir()) || os.tmpDir(),
keepExtensions: false,
allowEmptyFiles: true,
minFileSize: 1,
maxFileSize: 200 * 1024 * 1024,
maxFields: 1000,
maxFieldsSize: 20 * 1024 * 1024,
hash: false,
multiples: false,
onFileBegin: (name, file) => {
console.log(name);
console.log(file);
}
},
onError: (err) => {
console.log(JSON.stringify(err));
}
}
}
export default config;
// app/index.js
import Koa from 'koa';
import KoaBody from 'koa-body';
import Http from 'http';
import Https from 'https';
import Redis from '../redis';
import AppConf from './conf';
import Router from '../router';
import Controllers from '../controllers';
import Auth from '../auth';
import {
getLocalAndNetworkIP,
log
} from '../utils';
// 创建 koa 应用
const app = new Koa();
// 创建路由
const router = Router(Controllers);
// 将redis实例导入到koa实例中的上下文中，方便后期直接使用
app.context.redis = Redis;
// koa 正文解析器中间件，类似于 Express 中的bodyParser
app.use(KoaBody(AppConf.bodyConf));
// 权限验证
app.use(Auth);
// 嵌套路由
app.use(router.routes());
app.use(router.allowedMethods());
// 监听错误日志
app.on('error', err => {
log(err);
});
// 创建 Http 服务，并监听相应端口
Http.createServer(app.callback()).listen(AppConf.port);
// 创建 Https 服务，并监听相应端口
Https.createServer(app.callback()).listen(AppConf.port + 1);
/**
* 以下为开发使用
*/
if (process.env.NODE_ENV !== 'production') {
log(`App running at:`);
// 获取当前机器所有的 IPv4 的 IP
const {
localIp,
networkIpList
} = getLocalAndNetworkIP();
const ipList = [localIp, ...networkIpList];
ipList.forEach((item, index) => {
if (index) {
log(` - Network_http_${index + 1}: http://${item}:${AppConf.port}`);
log(` - Network_https_${index + 1}: https://${item}:${AppConf.port + 1}`);
} else {
log(` - Local_http_${index + 1}: http://${item}:${AppConf.port}`);
log(` - Local_https_${index + 1}: https://${item}:${AppConf.port + 1}`);
}
})
}
// auth/index.js
const validAuth = async (ctx, next) => {
if(ctx.headers.token) {
}
next();
}
export default validAuth;
// controllers/util.js
/**
* @description: 类的前缀装饰器
* @param {string} [prefix] - 前缀字段值
*/
export function prefixController(prefix) {
return function (target) {
target.prefix = prefix;
}
}
/**
* @description: 路由组合方法
* @param {string} [method] - 请求方式
* @param {string} [url] 请求路径
*/
function routerFn(method, url) {
return function (target, property) {
!target.routers && (target.routers = []);
target.routers.push({
name: property,
method,
url
});
}
}
/**
* @description: 自动生成所有的请求装饰器
* @return {object} [obj={}] - 返回所有方法的回调
*/
export function requstMethods() {
const methods = ['get', 'post', 'delete', 'put', 'options', 'head', 'patch', 'all'];
let obj = {};
for (let key of methods) {
obj[key] = function (url) {
return routerFn(key, url);
}
}
return obj;
}
// controllers/index.js
import User from './modules/user';
import Role from './modules/role';
export default {
User,
Role
}
// controllers/modules/user.js
import { prefixController, requstMethods } from '../util';
const {get, post} = requstMethods();
@prefixController('/user')
export default class User {
@get('/')
async getUserList(ctx) {
ctx.body = '12323'
}
@get('/info')
async getUserInfo(ctx) {
console.log(ctx);
}
@post('/add')
async addUserInfo(ctx) {
console.log(ctx);
}
}
// controllers/modules/role.js
import { prefixController, requstMethods } from '../util';
const {get, post} = requstMethods();
@prefixController('/role')
export default class Role {
@get('/')
getRoleList(ctx) {
console.log(ctx);
}
@get('/info')
getRoleInfo(ctx) {
console.log(ctx);
}
}
// db/conf.js
/**
* @description: Database Config
* @param {string} [database] - 数据库名称
* @param {string} [username=null] - 数据库用户名
* @param {string} [password=null] - 数据库密码（支持 SQLite 的 SQLCipher 加密）
* @param {object} [options={}] - 数据库的配置项
* @param {string} [options.host='localhost'] - 关系型数据库主机
* @param {number} [options.port=] - 关系型数据库的端口号
* @param {string} [options.username=null] - 数据库用户名的二次验证
* @param {string} [options.password=null] - 数据库密码的二次验证
* @param {string} [options.database=null] - 数据库名称
* @param {string} [options.dialect] - 要连接的数据库类型。 mysql, postgres, sqlite, mariadb 或者 mssql.
* @param {string} [options.dialectModule=null] - 如果指定，请使用此数据库。例如，如果在连接到pg数据库时希望使用pg.js而不是pg，则应在此处指定“require”（“pg.js”）”
* @param {string} [options.dialectModulePath=null] - 如果指定，请从此路径加载数据库。例如，如果要在连接到pg数据库时使用pg.js而不是pg，则应在此处指定“/path/to/pg.js”
* @param {object} [options.dialectOptions] - 附加选项的对象，这些选项直接传递到连接库
* @param {string} [options.storage] - 仅由sqlite使用。默认设置为：内存：'
* @param {string} [options.protocol='tcp'] - 关系数据库的协议。
* @param {object} [options.define={}] - 模型定义的默认选项。请参阅{@link Model.init}。
* @param {object} [options.query={}] - Default options for sequelize.query
* @param {string} [options.schema=null] - 要使用的模式
* @param {object} [options.set={}] - sequelize.set的默认选项
* @param {object} [options.sync={}] - sequelize.sync的默认选项
* @param {string} [options.timezone='+00:00'] - 将数据库中的日期转换为JavaScript日期时使用的时区。时区还用于在连接到服务器时设置时区，以确保NOW、CURRENT_TIMESTAMP和其他与时间相关的功能的结果位于正确的时区。为获得最佳跨平台性能，请使用+/-HH:MM格式。还将接受moment.js使用的时区的字符串版本（例如“America/Los_Angeles”）；这对于捕获夏令时更改非常有用。
* @param {string|boolean} [options.clientMinMessages='warning'] - PostgreSQL的'client_min_messages'会话参数。设置为'false'，不覆盖数据库的默认值。
* @param {boolean} [options.standardConformingStrings=true] - PostgreSQL的“standard_conforming_strings”会话参数。设置为'false'不设置选项。警告：将此设置为false可能会暴露漏洞，不建议使用！
* @param {Function} [options.logging=console.log] - 一个每次Sequelize都会执行的函数会记录一些东西。函数可以接收多个参数，但只有第一个参数由“console.log”打印。要打印所有值，请使用“（…msg）=>console.log（msg）`
* @param {boolean} [options.benchmark=false] - 将查询执行时间（毫秒）作为第二个参数传递给日志函数（options.logging）。
* @param {boolean} [options.omitNull=false] - 定义是否应将空值作为值传递以创建/更新SQL查询的标志。
* @param {boolean} [options.native=false] - 定义是否应使用本机库的标志。目前只对postgres有效
* @param {boolean} [options.replication=false] - 使用读/写复制。要启用复制，请传递一个具有两个属性（读和写）的对象。写入应该是一个对象（处理写入的单个服务器），读取一个对象数组（处理读取的多个服务器）。每个读/写服务器可以具有以下属性：`host`、`port`、`username`、`password`、`database``
* @param {object} [options.pool] - 续集连接池配置
* @param {number} [options.pool.max=5] - 池中的最大连接数
* @param {number} [options.pool.min=0] - 池中的最小连接数
* @param {number} [options.pool.idle=10000] - 在释放连接之前，连接可以处于空闲状态的最长时间（以毫秒为单位）。
* @param {number} [options.pool.acquire=60000] - 该池在引发错误之前尝试获取连接的最长时间（毫秒）
* @param {number} [options.pool.evict=1000] - sequelize池删除空闲连接的时间间隔（毫秒）。
* @param {Function} [options.pool.validate] - 验证连接的函数。打电话给客户。默认函数检查客户机是否为对象，以及其状态是否未断开连接
* @param {number} [options.pool.maxUses=Infinity] - 在放弃连接进行替换之前可以使用连接的次数，[`用于最终的群集重新平衡`](https://github.com/sequelize/sequelize-pool).
* @param {boolean} [options.quoteIdentifiers=true] - 设置为'false'，使Postgres上的表名和属性不区分大小写，并跳过它们的双引号。警告：将此设置为false可能会暴露漏洞，不建议使用！
* @param {string} [options.transactionType='DEFERRED'] - 设置默认事务类型。有关可能的选项，请参见“Sequelize.Transaction.TYPES”。仅限Sqlite。
* @param {string} [options.isolationLevel] - 设置默认事务隔离级别。有关可能的选项，请参见“Sequelize.Transaction.ISOLATION_Level”。
* @param {object} [options.retry] - 控制何时自动重试查询的标志集。接受[`按承诺重试`]的所有选项(https://github.com/mickhansen/retry-as-promised).
* @param {Array} [options.retry.match] - 仅当错误与这些字符串之一匹配时，才重试查询。
* @param {number} [options.retry.max] - 自动重试失败查询的次数。设置为0可禁用在SQL\u忙错误时重试。
* @param {boolean} [options.typeValidation=false] - 在insert和update上运行内置类型验证程序，并选择with where子句，例如，验证传递给integer字段的参数是否与integer类似。
* @param {object} [options.operatorsAliases] - 基于字符串的运算符别名。传递对象以限制一组别名运算符。
* @param {object} [options.hooks] - 在某些生命周期事件前后调用的全局钩子函数的对象。全局钩子将在为同一事件定义的任何特定于模型的钩子之后运行（有关列表，请参见`Sequelize.model.init（）`）。此外，这里还可以定义'beforeConnect（）`、'afterConnect（）`、'beforeDisconnect（）`和'afterDisconnect（）`挂钩。
* @param {boolean} [options.minifyAliases=false] - 定义是否应缩小别名的标志（主要用于避免Postgres别名字符限制为64）
* @param {boolean} [options.logQueryParameters=false] - 定义是否在日志中显示绑定参数的标志。
*/
export default {
database: 'dbtest',
username: 'root',
password: '123456',
options: {
dialect: 'mysql',
host: '127.0.0.1',
port: 3306
}
}
// db/index.js
import Sequelize from 'sequelize';
import DBConf from './conf';
const sequelize = new Sequelize(DBConf);
/**
* @description: 检测数据库连接是否正常
*/
async function checkDBConnect() {
try {
await sequelize.authenticate();
console.log('Connection has been established successfully.');
} catch (error) {
console.error('Unable to connect to the database:', error);
}
}
checkDBConnect();
export default sequelize;
// model/user.js
import { DataTypes, Model } from 'sequelize';
import { Sequelize } from '../db';
/**
* 在 Sequelize 中可以用两种等效的方式定义模型：
* a、调用 sequelize.define(modelName, attributes, options)
* b、扩展 Model 并调用 init(attributes, options)
*/
/**
* 以 a 方式创建用户模型
*/
// const User = Sequelize.define('User', {
// // 自定义模型属性
// }, {
// // 其他模型参数
// })
class User extends Model {}
User.init({
// 在这里定义模型属性
id: {
type: DataTypes.INET,
primaryKey: true,
autoIncrement: true,
},
name: {
type: DataTypes.STRING,
}
}, {
// 这是其他模型参数
Sequelize, // 我们需要传递连接实例
modelName: 'User', // 我们需要选择模型名称
tableName: 'User', // 表名
createdAt: false,
updatedAt: false,
timestamps: false
});
/**
* 定义的模型是类本身
* 即：User === Sequelize.models.User
*/
export default User;
// redis/conf.js
/**
* @description: Redis Server Config
* @param {number} [port=6379] - 端口
* @param {string} [host=localhost] - 主机
* @param {number} [family=4] - 4 (IPv4) or 6 (IPv6)
* @param {string} [path=null] - 本地 domain socket 路径
* 注意：如果设置了 port 那么 host 和 family 字段则会被忽略
* @param {number} [keepAlive=0] - 在开始启用之前，TCP 可以在 socket 上有多少毫秒的延迟
* 如果给 keepAlive 设置了非 number 类型的值，则禁用 keepAlive
* @param {boolean} [noDelay=true] - 是否禁用 Nagle 算法。默认情况下，我们禁用它以减少延迟
* @param {string} [connectionName=null] - 连接名称
* @param {number} [db=0] - 要使用的数据库索引
* @param {string} [password=null] - 如果设置了，客户端将在连接时发送带有此选项值的 AUTH 命令
* @param {string} [username=null] - 类似于 password ，为 Redis ACL 支持提供此选项
* @param {string} [dropBufferSupport=false] - 放弃缓冲区支持以获得更好的性能。建议在处理大型阵列响应时启用此选项，并且您不需要缓冲区支持。
* @param {boolean} [enableReadyCheck=true] - 当与 Redis 服务器建立连接时，服务器可能仍在从磁盘加载数据库。加载时，服务器不会响应任何命令。要解决此问题，当此选项为 true 时，ioredis 将检查 Redis 服务器的状态，当 Redis 服务器能够处理命令时，将发出 ready 事件。
* @param {boolean} [enableOfflineQueue=true] - 默认情况下，如果没有到 Redis 服务器的活动连接，则会将命令添加到队列中，并在连接“就绪”后执行（当 enableReadyCheck 为 true 时，“就绪”表示 Redis 服务器已从磁盘加载数据库，否则表示已建立到 Redis 服务器的连接）。如果此选项为 false ，则在连接未就绪时执行命令时，将返回一个错误。
* @param {number} [connectTimeout=10000] - 在初始连接到 Redis 服务器期间发生超时之前的毫秒数。
* @param {boolean} [autoResubscribe=true] - 重新连接后，如果以前的连接处于订阅模式，客户端将自动重新订阅这些通道。
* @param {boolean} [autoResendUnfulfilledCommands=true] - 如果为 true ，则在重新连接时，客户端将在上一个连接中重新发送未执行的命令（例如块命令）。
* @param {boolean} [lazyConnect=false] - 默认情况下，创建新的 Redis 实例时，它将自动连接到 Redis 服务器。如果要在调用命令之前保持实例断开连接，可以将 lazyConnect 选项传递给构造函数
* @param {Object} [tls] - TLS连接支持. 详情请查阅 https://github.com/luin/ioredis#tls-options
* @param {string} [keyPrefix=''] - 命令中所有键的前缀
* @param {function} [retryStrategy] - 请参阅“快速启动”部分
* @param {number} [maxRetriesPerRequest] - 请参阅“快速启动”部分
* @param {number} [maxLoadingRetryTime=10000] - 当 redis 服务器未就绪时，我们将等待 info 命令的'loading_eta_seconds'或 maxLoadingRetryTime（毫秒），以较小者为准。
* @param {function} [reconnectOnError] - 请参阅“快速启动”部分
* @param {boolean} [readOnly=false] - 为连接启用只读模式。仅适用于群集模式。
* @param {boolean} [stringNumbers=false] - 强制数字始终作为JavaScript字符串返回。处理大数字（超过[-2^53，+2^53]范围）时，此选项是必需的。
* @param {boolean} [enableTLSForSentinelMode=false] - 通过sentinel模式连接Redis时是否支持“tls”选项。
* @param {NatMap} [natMap=null] - sentinel连接器的NAT映射
* @param {boolean} [updateSentinels=true] - 在与现有"sentinel"通信时，使用新的IP地址更新给定的"sentinel"列表。
* @param {boolean} [failoverDetector=false] - 通过订阅相关通道主动检测故障转移。禁用此选项后，ioredis 仍然能够检测故障转移，因为每当发生故障转移时，Redis Sentinel 将断开所有客户端的连接，因此 ioredis 将重新连接到新的主机。当您希望更快地检测故障转移时，此选项非常有用，它将创建到 Redis 服务器的更多 TCP 连接，以便订阅相关通道
* @param {boolean} [enableAutoPipelining=false] - 启用时，事件循环迭代期间发出的所有命令将自动包装在管道中，并同时发送到服务器。这可以显著提高性能
* @param {string[]} [autoPipeliningIgnoredCommands=[]] - 不能自动包装在管道中的命令列表。
* @param {number} [maxScriptsCachingTime=60000] - 默认脚本定义缓存时间
* @extends [EventEmitter] - 详情请查阅 http://nodejs.org/api/events.html#events_class_events_eventemitter
* @extends Commander
*/
export default {
port: 6379, // 如果设置了 port ，则 host 和 family 不生效
host: 'localhost',
family: 4,
path: null,
keepAlive: 0,
noDelay: true,
connectionName: null,
db: 0,
password: null,
username: null,
dropBufferSupport: false,
enableReadyCheck: true,
enableOfflineQueue: true,
connectTimeout: 10000,
autoResubscribe: true,
autoResendUnfulfilledCommands: true,
lazyConnect: false,
// tls: {},
keyPrefix: '',
// retryStrategy: () => {},
// maxRetriesPerRequest: 0,
maxLoadingRetryTime: 10000,
// reconnectOnError: () => {},
readOnly: false,
stringNumbers: false,
enableTLSForSentinelMode: false,
natMap: null,
updateSentinels: true,
failoverDetector: false,
enableAutoPipelining: false,
autoPipeliningIgnoredCommands: [],
maxScriptsCachingTime: 60000
}
// redis/index.js
import Redis from 'ioredis';
import RedisConf from './conf';
const redis = new Redis(RedisConf);
export default redis;
// router/conf.js
/**
* @description: Koa Router Config
* @param {string} [prefix=''] - 路由前缀
* @param {array} [methods=['HEAD', 'OPTIONS', 'GET', 'PUT', 'PATCH', 'POST', 'DELETE']] - 支持的请求方法
*/
export default {
prefix: '',
methods: ['HEAD', 'OPTIONS', 'GET', 'PUT', 'PATCH', 'POST', 'DELETE']
}
// router/index.js
import Router from '@koa/router';
import RouterConf from './conf';
const router = new Router(RouterConf);
export default function (controllers) {
for (let key in controllers) {
const Temp = controllers[key];
let controller = new Temp();
let routes = [];
controller.routers.forEach(r => {
router[r.method](Temp.prefix + (r.url === '/' ? '' : r.url), controller[r.name]);
let route = {
name: controller[r.name].name,
method: r.method,
url: Temp.prefix + (r.url === '/' ? '' : r.url)
}
routes.push(route);
})
console.log(`${key}注册成功的路由有：\n\t${JSON.stringify(routes)}`);
}
return router;
}
// services/baseServices.js
export default class BaseService {
constructor() {
this.model = {}
}
/**
* @description: 获取
* @param {string|number} id - 唯一ID
*/
async getById(id) {
return await this.model.findByPk(id)
}
async getList(where) {
return await this.model.findAndCountAll({
where,
offset: 0,
limit: 10
})
}
async save(data) {
if (data.id) {
return this.update(data)
}
console.log(data, 'save')
return await this.add(data)
}
async update(data) {
return await this.model.update(data, {
where: {
id: data.id
}
})
}
async add(data) {
return await this.model.create(data)
}
async del(id) {
return this.model.destroy({
where: {
id
}
})
}
}
// services/user.js
import BaseService from './baseService';
import UserModel from '../model/user';
export default class UserService extends BaseService {
constructor() {
super()
this.model = UserModel;
}
}
// utils/index.js
import os from 'os';
import logColors from 'node-console-colors';
/**
* @description: 获取本地和网络的IPv4地址
* @return {object} - localIp: 本地IP，networkIpList: 网络IP列表
*/
export const getLocalAndNetworkIP = () => {
const networkInterfaces = os.networkInterfaces();
let localIp = '127.0.0.1';
let networkIpList = [];
for (const [key, values] of Object.entries(networkInterfaces)) {
values.forEach(({
address,
family,
internal
}) => {
family === 'IPv4' && internal && (localIp = address);
family === 'IPv4' && !internal && (networkIpList.push(address));
})
}
return {
localIp,
networkIpList
}
}
/**
* @description: 美化 console.log
* @param {array|string} [msg=''] - 消息体
* @param {string} [color=''] - 消息体字体颜色
* @param {string} [bgColor=''] - 消息体背景颜色
*/
export const log = (msg = '', color = '', bgColor = '') => {
const type = typeof msg;
if (type === 'object' && !Array.isArray(msg)) {
msg = JSON.stringify(msg);
}
if (type === 'undefined') {
msg = 'undefined';
}
const colors = ['black', 'dark_gray', 'gray', 'white', 'dark_red', 'red', 'dark_yellow', 'yellow', 'dark_cyan', 'cyan', 'dark_green', 'green', 'dark_blue', 'blue', 'dark_purple', 'purple', 'default'];
if (colors.indexOf(color) === -1) {
color = 'dark_cyan';
}
if (colors.indexOf(bgColor) !== -1) {
if (Array.isArray(msg)) {
console.log(logColors.set('fg_' + color, 'bg_' + bgColor, msg.join()));
} else {
console.log(logColors.set('fg_' + color, 'bg_' + bgColor, msg));
}
} else {
if (Array.isArray(msg)) {
console.log(logColors.set('fg_' + color, msg.join()));
} else {
console.log(logColors.set('fg_' + color, msg));
}
}
}
// index.js
import './app';
未完待续
类似资料：