koa2+log4js+sequelize搭建的nodejs服务

• 主要参考http://www.jianshu.com/p/6b816c609669这篇文章
• npm安装使用国内taobao镜像，速度更快些 npm --registry https://registry.npm.taobao.org install --save cross-env；
• 启动nodejs服务，如果配置了不同的环境设置，需安装cross-env ，使用cross-env解决跨平台设置NODE_ENV的问题
• app.use(async (ctx, next) => {
    await next();
    ctx.body = 'Hello World';
  });
  想要获取post请求中的参数要使用ctx.request.body

1 构建项目
1.1 安装koa-generator 这是一个开源框架
npm install -g koa-generator

1.2 使用koa-generator生成koa2项目
进入工作目录 cd work

然后执行下面命令生成完整项目目录和文件
koa2 HelloKoa2

创建项目成功后，进入项目目录

cd HelloKoa2

然后执行下面命令，安装依赖的插件
npm --registry https://registry.npm.taobao.org install

如果执行失败，并且提示【Please try running this command again as root/Administrator.】，应该是执行权限不够。找到CMD的命令提示工具，用管理员权限打开，进入项目根目录，执行上面命令，

1.3 启动项目

默认的启动脚本如下：

  "scripts": {
    "start": "node bin/www",
    "dev": "./node_modules/.bin/nodemon bin/www",
    "prd": "pm2 start bin/www",
    "test": "echo \"Error: no test specified\" && exit 1"
  },

默认端口在 bin/www文件中设置

执行 npm start ，如果不考虑自动重启功能，其实这句代码相当于执行了node bin/run 然后即可访问 网址http://127.0.0.1:3000/

也可执行npm run dev，此处配置是使用了nodemon插件，nodemon插件的作用是在你启动了服务之后，修改文件可以自动重启服务。

2 项目配置

这里需要根据不同环境配置不同的启动字符串，例如

    "start": "cross-env NODE_ENV=development ./node_modules/.bin/nodemon bin/www",
    "koa": "./node_modules/.bin/nodemon bin/www",
    "prd": "pm2 start bin/www",
    "test": "cross-env NODE_ENV=test ./node_modules/.bin/nodemon bin/www",
    "pro":"cross-env NODE_ENV=production ./node_modules/.bin/nodemon bin/www"

2.2 npm scripts
我们在scripts对象中添加一段代码"start_koa": "bin/run"，需要npm run start_koa 这样执行
在npm中，有四个常用的缩写
    npm start是npm run start
    npm stop是npm run stop的简写
    npm test是npm run test的简写
    npm restart是npm run stop && npm run restart && npm run start的简写
其他的都要使用npm run来执行了。

如果需要执行普通的js文件，只需 node init_db 即可。

2.3 配置环境
关于配置环境常用的有development、test、production、debug。可以使用node提供的process.env.NODE_ENV来设置。

在bin/www 文件中加入下面语句，查看输出

console.log("process.env.NODE_ENV=" + process.env.NODE_ENV);

在windows下如此 执行Set NODE_ENV=test && npm start  可以看到输出的环境日志为test。只是赋值，如果加入配置文件后，此方式不管用，需在脚本中配置环境变量。例如：

  "scripts": {
    "start": "cross-env NODE_ENV=development ./node_modules/.bin/nodemon bin/www",
    "test": "cross-env NODE_ENV=test ./node_modules/.bin/nodemon bin/www",
    "pro":"cross-env NODE_ENV=production ./node_modules/.bin/nodemon bin/www"
  },

2.4 配置文件
首先在项目根目录下添加config目录，在config目录下添加index.js、test.js、development.js个文件
development.js 文件中如此定义

module.exports = {
    env: 'development', //环境名称
    webport: 3001         //服务端口号
}

test.js文件中如此定义

module.exports = {
    env: 'test',        //环境名称
    webport: 3002         //服务端口号
}

index.js文件中如此定义

var development_env = require('./development');
var test_env = require('./test');
var production_env=require('./production');

//根据不同的NODE_ENV，输出不同的配置对象，默认输出development的配置对象
module.exports = {
    development: development_env,
    test: test_env,
    production:production_env
}[process.env.NODE_ENV || 'development']

bin/www添加如下代码

//引入配置文件
var config = require('../config');
console.log("process.env.NODE_ENV=" + process.env.NODE_ENV);
// 将端口号设置为配置文件的端口号，默认值为3000
var port = normalizePort(config.webport|| '3000');
// 打印输出端口号
console.log('port = ' + config.webport);

3 日志
在app.js文件中，框架已包含一个日志插件

const logger = require('koa-logger');
app.use(convert(logger()));

// logger
app.use(async (ctx, next) => {
  const start = new Date()
  await next()
  const ms = new Date() - start
  console.log(`${ctx.method} ${ctx.url} - ${ms}ms`)
})

3.1 log4js
log4js提供了多个日志等级分类，同时也能替换console.log输出，另外他还可以按照文件大小或者日期来生成本地日志文件，还可以使用邮件等形式发送日志。
用info和error两种日志等级分别记录响应日志和错误日志。

3.2 log4js 配置

安装log4js插件 会提示Please try running this command again as root/Administrator.  错误, 先用管理员权限执行cmd窗口，然后进入项目，再执行下面语句
npm --registry https://registry.npm.taobao.org install  log4js --save，如果还是会提示错误，就关掉cmd窗口，再重新打开一个，进入项目根目录，再执行一次。
在config目录下创建一个log_config.js文件，log4js@1 和log4js@2 两个版本有差异，现以2.x版本为例

var path = require('path');

//日志根目录
var baseLogPath = path.resolve(__dirname, '../logs')

//错误日志目录
var errorPath = "/error";
//错误日志文件名
var errorFileName = "error";
//错误日志输出完整路径
var errorLogPath = baseLogPath + errorPath + "/" + errorFileName;
//var errorLogPath = path.resolve(__dirname, "../logs/error/error");

//响应日志目录
var responsePath = "/response";
//响应日志文件名
var responseFileName = "response";
//响应日志输出完整路径
var responseLogPath = baseLogPath + responsePath + "/" + responseFileName;
//var responseLogPath = path.resolve(__dirname, "../logs/response/response");
module.exports = {
　　//日志格式等设置
    appenders:
    {
        "rule-console": {"type": "console"},
        "errorLogger": {
            "type": "dateFile",
            "filename": errorLogPath,
            "pattern": "-yyyy-MM-dd-hh.log",
            "alwaysIncludePattern": true,
            "encoding":"utf-8",
            "maxLogSize": 1000,
            "numBackups": 3,
            "path":errorPath
        },
        "resLogger": {
            "type": "dateFile",
            "filename": responseLogPath,
            "pattern": "-yyyy-MM-dd-hh.log",
            "alwaysIncludePattern": true,
            "encoding":"utf-8",
            "maxLogSize": 1000,
            "numBackups": 3,
            "path":responsePath
        },
    },
 　　//供外部调用的名称和对应设置定义
    categories: {
        "default": {"appenders": ["rule-console"], "level": "all"},
        "resLogger": {"appenders": ["resLogger"], "level": "info"},
        "errorLogger": {"appenders": ["errorLogger"], "level": "error"},
        "http": {"appenders": ["resLogger"],"level": "info"}
    },
    "baseLogPath": baseLogPath
}

然后创建一个utils目录，添加log_util.js文件

var log4js = require('log4js');

var log_config = require('../config/log_config');

//加载配置文件
log4js.configure(log_config);

var logUtil = {};
//调用预先定义的日志名称
var resLogger = log4js.getLogger("resLogger");
var errorLogger = log4js.getLogger("errorLogger");
var consoleLogger = log4js.getLogger();

//封装错误日志
logUtil.logError = function (ctx, error, resTime) {
    if (ctx && error) {
        errorLogger.error(formatError(ctx, error, resTime));
    }
};

//封装响应日志
logUtil.logResponse = function (ctx, resTime) {
    if (ctx) {
        resLogger.info(formatRes(ctx, resTime));
    }
};

logUtil.logInfo = function (info) {
    if (info) {

        consoleLogger.info( formatInfo(info));
    }
};

var formatInfo = function (info) {
    var logText = new String();
    //响应日志开始
    logText += "\n" + "***************info log start ***************" + "\n";

    //响应内容
    logText += "info detail: " + "\n" + JSON.stringify(info) + "\n";

    //响应日志结束
    logText += "*************** info log end ***************" + "\n";

    return logText;
}

//格式化响应日志
var formatRes = function (ctx, resTime) {
    var logText = new String();
    //响应日志开始
    logText += "\n" + "*************** response log start ***************" + "\n";

    //添加请求日志
    logText += formatReqLog(ctx.request, resTime);

    //响应状态码
    logText += "response status: " + ctx.status + "\n";

    //响应内容
    logText += "response body: " + "\n" + JSON.stringify(ctx.body) + "\n";

    //响应日志结束
    logText += "*************** response log end ***************" + "\n";

    return logText;

}

//格式化错误日志
var formatError = function (ctx, err, resTime) {
    var logText = new String();

    //错误信息开始
    logText += "\n" + "*************** error log start ***************" + "\n";

    //添加请求日志
    logText += formatReqLog(ctx.request, resTime);

    //错误名称
    logText += "err name: " + err.name + "\n";
    //错误信息
    logText += "err message: " + err.message + "\n";
    //错误详情
    logText += "err stack: " + err.stack + "\n";

    //错误信息结束
    logText += "*************** error log end ***************" + "\n";

    return logText;
};

//格式化请求日志
var formatReqLog = function (req, resTime) {

    var logText = new String();

    var method = req.method;
    //访问方法
    logText += "request method: " + method + "\n";

    //请求原始地址
    logText += "request originalUrl:  " + req.originalUrl + "\n";

    //客户端ip
    logText += "request client ip:  " + req.ip + "\n";

    //开始时间
    var startTime;
    //请求参数
    if (method === 'GET') {
        logText += "request query:  " + JSON.stringify(req.query) + "\n";
        // startTime = req.query.requestStartTime;
    } else {
        logText += "request body: " + "\n" + JSON.stringify(req.body) + "\n";
        // startTime = req.body.requestStartTime;
    }
    //服务器响应时间
    logText += "response time: " + resTime + "\n";

    return logText;
}

module.exports = logUtil;

接下来修改app.js 文件中的logger部分，先把原有的日志部分注释掉，然后加入下列代码：

//log工具
const logUtil = require('./utils/log_util');

// logger
app.use(async (ctx, next) => {
  //响应开始时间
  const start = new Date();
  //响应间隔时间
  var ms;
  try {
    //开始进入到下一个中间件
    await next();

    ms = new Date() - start;
    //记录响应日志
    logUtil.logResponse(ctx, ms);

  } catch (error) {

    ms = new Date() - start;
    //记录异常日志
    logUtil.logError(ctx, error, ms);
  }
});

在这将await next();放到了一个try catch里面，这样后面的中间件有异常都可以在这集中处理。
比如你会将一些API异常作为正常值返回给客户端，就可以在这集中进行处理。然后后面的中间件只要throw自定义的API异常就可以

3.3 初始化logs文件目录
打开bin/www文件 添加

var fs = require('fs');
var logConfig = require('../config/log_config');

/**
 * 确定目录是否存在，如果不存在则创建目录
 */
var confirmPath = function(pathStr) {

  if(!fs.existsSync(pathStr)){
      fs.mkdirSync(pathStr);
      console.log('createPath: ' + pathStr);
    }
}

/**
 * 初始化log相关目录
 */
var initLogPath = function(){
  //创建log的根目录'logs'
  if(logConfig.baseLogPath){
    confirmPath(logConfig.baseLogPath)
    //根据不同的logType创建不同的文件目录
    for(var i = 0, len = logConfig.appenders.length; i < len; i++){
      if(logConfig.appenders[i].path){
        confirmPath(logConfig.baseLogPath + logConfig.appenders[i].path);
      }
    }
  }
}

initLogPath();

这样每次启动服务的时候，都会去确认一下相关的文件目录是否存在，如果不存在就创建相关的文件目录。

3.4 配置规则

configure方法为配置log4js对象，内部有levels、appenders、categories三个属性
 levels:
 配置日志的输出级别,共ALL<TRACE<DEBUG<INFO<WARN<ERROR<FATAL<MARK<OFF八个级别,default level is OFF

只有大于等于日志配置级别的信息才能输出出来，可以通过category来有效的控制日志输出级别
appenders:
配置文件的输出源，一般日志输出type共有console、file、dateFile三种
console:普通的控制台输出
file:输出到文件内，以文件名-文件大小-备份文件个数的形式rolling生成文件
dateFile:输出到文件内，以pattern属性的时间格式，以时间的生成文件

replaceConsole:

是否替换控制台输出，当代码出现console.log，表示以日志type=console的形式输出

1、type:console
将日志输出至控制台，这样可以方便开发人员在开发时接看到所有日志信息，在其他环境不建议设置
2、alwaysIncludePattern
如果为true，则每个文件都会按pattern命名，否则最新的文件不会按照pattern命名
3、replaceConsole
如果为true，则程序中用console.log输出到控制台的信息，也会输出到日志文件中，且格式按照log4js的格式输出，如果为false，则console.log只会输出在控制台。与type:console的appender正好相反，如果设置了type:console，则会将log4js.log日志输出至控制台。
4、category
没有看到权威的说明，我的理解category就是一个日志名字，如果没有取应该是默认的。只有当开发人员通过getLogger(category)获得相对应的日志时，才能输出到对应的appender中，否则会发送给所有默认的appender
5、logLevelFilter
没有看到什么文档说明，但实际的例子还是不少，直观理解应该就是根据日志级别进行日志过滤。

filename: __dirname + '/logs/test.log',//文件目录，当目录文件或文件夹不存在时，会自动创建
maxLogSize : 10,//文件最大存储空间，当文件内容超过文件存储空间会自动生成一个文件test.log.1的序列自增长的文件
backups : 3,//default value = 5.当文件内容超过文件存储空间时，备份文件的数量
//compress : true,//default false.是否以压缩的形式保存新文件,默认false。如果true，则新增的日志文件会保存在gz的压缩文件内，并且生成后将不被替换，false会被替换掉
encoding : 'utf-8',//default "utf-8"，文件的编码

3.5 基本使用

var log4js = require('log4js');

var logger = log4js.getLogger();

logger.level = 'debug';

logger.debug("Some debug messages");

或者var resLogger = log4js.getLogger("resLogger");这里取的属性名称为categories中的名称

当前封装的方法为：

//log工具
const logUtil = require('./utils/log_util');
//记录响应日志
logUtil.logResponse(ctx, ms);
//记录异常日志
logUtil.logError(ctx, error, ms);

4 格式化输出

假设我们现在开发的是一个API服务接口，会有一个统一的响应格式，同时也希望发生API错误时统一错误格式。

4.1 建立路由接口

框架默认生成的路由接口在routes文件夹下，index.js

const router = require('koa-router')()

router.get('/', async (ctx, next) => {
  await ctx.render('index', {
    title: 'Hello Koa 2!'
  })
})

router.get('/string', async (ctx, next) => {
  ctx.body = 'koa2 string'
})

router.get('/json', async (ctx, next) => {
  ctx.body = {
    title: 'koa2 json'
  }
})

module.exports = router

‘/’为路由接口的根路径，'/string' 为路由接口名称

users.js文件

const router = require('koa-router')()

router.prefix('/users')

router.get('/', function (ctx, next) {
  ctx.body = 'this is a users response!'
})

router.get('/bar', function (ctx, next) {
  ctx.body = 'this is a users/bar response'
})

module.exports = router

定义完路由文件后，在app.js中注册一下

// routes
app.use(index.routes(), index.allowedMethods())
app.use(users.routes(), users.allowedMethods())

我们希望服务的地址的组成是这要的
域名 + 端口号 /api/功能类型/具体端口

以上就可以实现我们的需求，运行服务后可以访问 http://127.0.0.1:3001/users，页面会显示  “this is a users response!”

4.2 格式化输出

如果我们想使服务返回下面的json结果

json格式
{
    "code": 0,
    "message": "成功",
    "data": {
      "username": “王团团",
      "age": 30
    }
}

我们要处理数据应该在发送响应之前和路由得到数据之后添加一个中间件。在项目的根目录下添加一个middlewares目录，在该目录下添加response_formatter.js文件

/**
 * 在app.use(router)之前调用
 */
var response_formatter = async (ctx, next) => {
    //先去执行路由
    await next();

    //如果有返回数据，将返回数据添加到data中
    if (ctx.body) {
        ctx.body = {
            code: 0,
            message: 'success',
            data: ctx.body
        }
    } else {
        ctx.body = {
            code: 0,
            message: 'success'
        }
    }
}

module.exports = response_formatter;

然后在app.js中载入

const response_formatter = require('./middlewares/response_formatter');

在app.js 在添加路由之前调用

app.use(response_formatter);

这样所有的路由接口都被json格式化。

4.3 对URL进行过滤

修改一下response_formatter.js文件

/**
 * 在app.use(router)之前调用
 */
var response_formatter = (ctx) => {
    //如果有返回数据，将返回数据添加到data中
    if (ctx.body) {
        ctx.body = {
            code: 0,
            message: 'success',
            data: ctx.body
        }
    } else {
        ctx.body = {
            code: 0,
            message: 'success'
        }
    }
}
//指定前缀过滤
var url_filter = function(pattern){

    return async function(ctx, next){
        var reg = new RegExp(pattern);
        //先去执行路由
        await next();
        //通过正则的url进行格式化处理
        if(reg.test(ctx.originalUrl)){
            response_formatter(ctx);
        }
    }
}
module.exports = url_filter;

//添加格式化处理响应结果的中间件，过滤指定前缀的接口名称，在添加路由之前调用

app.use(response_formatter('^/users'));

这样，只有访问http://127.0.0.1:3001/users接口时才会进行json格式化

4.4 API异常处理
创建一个API异常类，在app目录下新建一个error目录，添加ApiError.js文件

/**
 * 自定义Api异常
 */
class ApiError extends Error {

    //构造方法
    constructor(error_name, error_code, error_message) {
        super();
        this.name = error_name;
        this.code = error_code;
        this.message = error_message;
    }
}

module.exports = ApiError;

为了让自定义Api异常能够更好的使用，我们创建一个ApiErrorNames.js文件来封装API异常信息，并可以通过API错误名称获取异常信息。

/**
 * API错误名称
 */
var ApiErrorNames = {};

ApiErrorNames.UNKNOW_ERROR = "unknowError";
ApiErrorNames.USER_NOT_EXIST = "userNotExist";

/**
 * API错误名称对应的错误信息
 */
const error_map = new Map();

error_map.set(ApiErrorNames.UNKNOW_ERROR, { code: -1, message: '未知错误' });
error_map.set(ApiErrorNames.USER_NOT_EXIST, { code: 101, message: '用户不存在' });

//根据错误名称获取错误信息
ApiErrorNames.getErrorInfo = (error_name) => {

    var error_info;

    if (error_name) {
        error_info = error_map.get(error_name);
    }

    //如果没有对应的错误信息，默认'未知错误'
    if (!error_info) {
        error_name = UNKNOW_ERROR;
        error_info = error_map.get(error_name);
    }

    return error_info;
}

module.exports = ApiErrorNames;

修改ApiError.js文件，引入ApiErrorNames

const ApiErrorNames = require('./ApiErrorNames');

const ApiErrorNames = require('./ApiErrorNames');

/**
 * 自定义Api异常
 */
class ApiError extends Error{
    //构造方法
    constructor(error_name){
        super();

        var error_info = ApiErrorNames.getErrorInfo(error_name);

        this.name = error_name;
        this.code = error_info.code;
        this.message = error_info.message;
    }
}

module.exports = ApiError;

在response_formatter.js文件中处理API异常
先引入ApiError:

var ApiError = require('../app/error/ApiError');

然后修改url_filter

/**
 * 在app.use(router)之前调用
 */
var ApiError = require('../app/error/ApiError');
 var response_formatter = (ctx) => {
    //如果有返回数据，将返回数据添加到data中
    if (ctx.body) {
        ctx.body = {
            code: 0,
            message: 'success',
            data: ctx.body
        }
    } else {
        ctx.body = {
            code: 0,
            message: 'success'
        }
    }
}

var url_filter = (pattern) => {
    return async (ctx, next) => {
        var reg = new RegExp(pattern);
        try {
            //先去执行路由
            await next();
        } catch (error) {
            //如果异常类型是API异常并且通过正则验证的url，将错误信息添加到响应体中返回。
            if(error instanceof ApiError && reg.test(ctx.originalUrl)){
                ctx.status = 200;
                ctx.body = {
                    code: error.code,
                    message: error.message
                }
            }
            //继续抛，让外层中间件处理日志
            throw error;
        }

        //通过正则的url进行格式化处理
        if(reg.test(ctx.originalUrl)){
            response_formatter(ctx);
        }
    }
}

module.exports = url_filter;

1. 使用try catch包裹await next();，这样后面的中间件抛出的异常都可以在这几集中处理；
2. 　throw error;是为了让外层的logger中间件能够处理日志。

模拟效果，修改routes/users.js 文件

const ApiError = require('../app/error/ApiError');
const ApiErrorNames = require('../app/error/ApiErrorNames');
const router = require('koa-router')()

router.prefix('/users')

router.get('/', function (ctx, next) {
  ctx.body = 'this is a users response!'
})

router.get('/bar', function (ctx, next) {
  ctx.body = 'this is a users/bar response'
})
router.post('/post', function (ctx, next) {
  console.log('post', ctx.request.body);
})
//测试接口
router.get('/getUser', function (ctx, next) {
  //如果id != 1抛出API 异常
  if (ctx.query.id != 1) {
    throw new ApiError(ApiErrorNames.USER_NOT_EXIST);
  }
  ctx.body = {
    username: '王团团',
    age: 1
  }
})

module.exports = router

然后访问127.0.0.1:3001/users/getUser，127.0.0.1:3001/users/getUser?id=1比对测试结果

5.  引入ORM工具 Sequelize

参考文章为 https://github.com/demopark/sequelize-docs-Zh-CN

5.1 安装Sequelize

// 使用 NPM
npm --registry https://registry.npm.taobao.org install --save sequelize
//根据需求选择
npm --registry https://registry.npm.taobao.org install --save pg pg-hstore
npm --registry https://registry.npm.taobao.org install --save mysql2
npm --registry https://registry.npm.taobao.org install --save sqlite3
npm --registry https://registry.npm.taobao.org install --save tedious // MSSQL

如果提示Please try running this command again as root/Administrator.  错误, 先用管理员权限执行cmd窗口，然后进入项目，再执行上面语句，还提示同样的错误，就关掉现有窗口，重新打开窗口执行。

5.2 安装Installing CLI 进行数据迁移

npm --registry https://registry.npm.taobao.org install --save sequelize-cli

5.3 迁移框架初始化

初始化命令

sequelize init

　　这将默认创建以下文件夹

• config, 包含配置文件，它告诉CLI如何连接数据库
• models,包含您的项目的所有模型
• migrations, 包含所有迁移文件
• seeders, 包含所有种子文件

如果要创建自定义的文件目录，需在项目根目录下新建 .sequelizerc文件，配置如下：

const path = require('path');

module.exports = {
  'config': path.resolve('config', 'config.js'),
  'models-path': path.resolve('db', 'models'),
  'seeders-path': path.resolve('db', 'seeders'),
  'migrations-path': path.resolve('db', 'migrations')
}

Sequelize CLI可以从“JSON”和“JS”文件中读取。所以默认的配置文件名字database.json和自定义的config.js都可以。

执行 目录初始化语句后 修改config/config.js文件内容

module.exports = {
  development: {
    username: 'database_dev',
    password: 'database_dev',
    database: 'database_dev',
    host: '127.0.0.1',
    dialect: 'mysql'
  },
  test: {
    username: process.env.CI_DB_USERNAME,
    password: process.env.CI_DB_PASSWORD,
    database: process.env.CI_DB_NAME,
    host: '127.0.0.1',
    dialect: 'mysql'
  },
  production: {
    username: process.env.PROD_DB_USERNAME,
    password: process.env.PROD_DB_PASSWORD,
    database: process.env.PROD_DB_NAME,
    host: process.env.PROD_DB_HOSTNAME,
    dialect: 'mysql'
  }
}

如果你的数据库还不存在，你可以调用Sequelize db:create xxx 命令。

如果想实现下面这种形式的配置

test: {
    username: process.env.CI_DB_USERNAME,
    password: process.env.CI_DB_PASSWORD,
    database: process.env.CI_DB_NAME,
    host: '127.0.0.1',
    dialect: 'mysql'
  }

需要先在项目根目录下新建  .env文件，然后把定义好变量名称和变量值，例如

LOCAL_DATABASE="testdb"
LOCAL_USERNAME="root"
LOCAL_PASSWORD="!QAZ2wsx"

然后安装dotenv插件

npm --registry https://registry.npm.taobao.org install --save dotenv

如果出现权限问题，关掉cmd窗口，重新用管理员权限打开窗口再执行上面命令。

然后在config.js 文件中引入

require('dotenv').config();

完整的内容为

require('dotenv').config();
module.exports = {
  development: {
    username: process.env.LOCAL_USERNAME,
    password: process.env.LOCAL_PASSWORD,
    database: process.env.LOCAL_DATABASE,
    host: '127.0.0.1',
    dialect: 'mysql'
  },
  test: {
    username: 'root',
    password: '!QAZ2wsx',
    database: 'testdb1',
    host: '127.0.0.1',
    dialect: 'mysql'
  },
  production: {
    username: 'root',
    password: '!QAZ2wsx',
    database: 'testdb2',
    host: '127.0.0.1',
    dialect: 'mysql'
  }
}

之前配置的development.js,test.js,production.js三个环境变量配置文件可以删掉，整合到config.js,修改后为

const fs = require('fs');
require('dotenv').config();
module.exports = {
  development: {
    username: process.env.LOCAL_USERNAME,
    password: process.env.LOCAL_PASSWORD,
    database: process.env.LOCAL_DATABASE,
    host: '127.0.0.1',
    dialect: 'mysql',
    port:'3306',
　　webport:'3001'
  },
  test: {
    username: 'root',
    password: '!QAZ2wsx',
    database: 'testdb2',
    host: '127.0.0.1',
    dialect: 'mysql',
    port:'3306',
　　webport:'3002'
  },
  production: {
    username: 'root',
    password: '!QAZ2wsx',
    database: 'testdb3',
    host: '127.0.0.1',
    dialect: 'mysql',
    port:'3306',
　　webport:'3003'
  }
}

config/index.js文件也需要修改

var db = require('./config');

//根据不同的NODE_ENV，输出不同的配置对象，默认输出development的配置对象
module.exports = {
    development: db.development,
    test: db.test,
    production:db.production
}[process.env.NODE_ENV || 'development']

5.4 创建model

sequelize model:generate --name UserInfo --attributes firstName:string,lastName:string,email:string

在 models 文件夹中创建了一个 UserInfo 模型文件
在 migrations 文件夹中创建了一个名字像 XXXXXXXXXXXXXX-create-userinfo.js 的迁移文件

Sequelize 将只使用模型文件，它是表描述。另一边，迁移文件是该模型的更改，或更具体的是说 CLI 所使用的表。 处理迁移，如提交或日志，以进行数据库的某些更改。

系统默认的环境变量是development，在model/index.js中配置

var env       = process.env.NODE_ENV || 'development';
var config    = require(__dirname + '/..\..\config\config.js')[env];

如果想使用test环境或者production的环境变量生成，则执行下面命令

set NODE_ENV=test&&sequelize db:migrate

当没用运行服务，只是在命令行执行设置当前环境变量的命令是

set NODE_ENV=test

5.5 执行迁移

sequelize db:migrate

此命令将执行这些步骤

• 将在数据库中确保一个名为 SequelizeMeta 的表。 此表用于记录在当前数据库上运行的迁移
• 开始寻找尚未运行的任何迁移文件。 这可以通过检查 SequelizeMeta 表。 在这个例子中，它将运行我们在最后一步中创建的 XXXXXXXXXXXXXX-create-userinfo.js 迁移，。
• 创建一个名为 UserInfos 的表，其中包含其迁移文件中指定的所有列。

执行配置的数据库中会生成两个表sequelizemeta, userinfos

5.6 撤销迁移

5.6.1 恢复最近的迁移

sequelize db:migrate:undo

5.6.2 撤消所有迁移，可以恢复到初始状态

Sequelize db:migrate:undo:all

5.6.3 恢复到特定的迁移

sequelize db:migrate:undo:all --to XXXXXXXXXXXXXX-create-posts.js

5.7 创建种子

有些时候需要在表中插入默认值，所以可以创建一个种子文件，它会将一个演示用户添加到我们的 UserInfos 表中

sequelize seed:generate --name demo-user

这个命令将会在 seeders 文件夹中创建一个种子文件。文件名看起来像是 XXXXXXXXXXXXXX-demo-user.js，它遵循相同的 up/down 语义，如迁移文件。

现在我们应该编辑这个文件，将演示用户插入User表。

'use strict';

module.exports = {
  up: (queryInterface, Sequelize) => {
    return queryInterface.bulkInsert('UserInfos', [{
        firstName: 'John',
        lastName: 'Doe',
        email: 'demo@demo.com'
      }], {});
  },

  down: (queryInterface, Sequelize) => {
    return queryInterface.bulkDelete('UserInfos', null, {});
  }
};

5.8 执行种子文件

sequelize db:seed:all

执行命令后可能会出现下面错误提示

ERROR: Field 'createdAt' doesn't have a default value

是因为默认生成的createdAt， updatedAt两个属性需要设定默认值，所以修改XXXXXXXXXXXXXX-demo-user.js文件为

'use strict';

module.exports = {
  up: (queryInterface, Sequelize) => {
    var now = new Date();
    return queryInterface.bulkInsert('UserInfos', [{
      firstName: 'John',
      lastName: 'Doe',
      email: 'demo@demo.com',
      createdAt: now,
      updatedAt: now
    }], {});
  },

  down: (queryInterface, Sequelize) => {
    return queryInterface.bulkDelete('UserInfos', null, {});
  }
};

这将执行该种子文件，您将有一个演示用户插入 UserInfos 表。

5.9 撤销种子

5.9.1 撤销最近的种子

sequelize db:seed:undo

5.9.2 撤销所有种子

sequelize db:seed:undo:all

6 Sequelize使用

6.1 测试数据库连接

新建db/dbInstance.js 文件，在此初始化数据库连接

var config = require('../config');
const Sequelize = require('sequelize');

const sequelize = new Sequelize(config.database, config.username, config.password, {
    host: config.host,
    dialect: 'mysql',

    pool: {
      max: 5,
      min: 0,
      idle: 10000
    }
  });

  module.exports = sequelize

在路由接口 routes/user.js 中引入dbInstance.js文件

var sequelize = require('../db/dbInstance');

然后在user.js 文件中新建一个接口方法

router.get('/search', function (ctx, next) {
  sequelize
  .authenticate()
  .then(() => {
    console.log('Connection has been established successfully.');
  })
  .catch(err => {
    console.error('Unable to connect to the database:', err);
  });
  ctx.body="this is a test function";
})

测试数据库连接成功，则命令行log日志输出

Executing (default): SELECT 1+1 AS result
Connection has been established successfully.

一个简单的查询应用

在routes/user.js文件中加入下面代码

const Sequelize = require('sequelize');

var UserInfo = sequelize.define('UserInfo', {
  firstName: Sequelize.STRING,
  lastName: Sequelize.STRING,
  email: Sequelize.STRING
}
);

router.get('/search', function (ctx, next) {

  (async () => {
    var users = await UserInfo.findAll({
        // where: {
        //     lastName: 'Doe'
        // }
    });
    console.log(`find ${users.length} users:`);
    for (let u of users) {
        console.log(JSON.stringify(u));
    }
})();

  ctx.body = "this is a test function";
})

再次访问此方法，命令行log日志输出

GET /users/search - 6ms
  --> GET /users/search  17ms 23b
Executing (default): SELECT `id`, `firstName`, `lastName`, `email`, `createdAt`, `updatedAt` FROM `UserInfos` AS `UserInfo`;
find  users:
{"id":,"firstName":"John1","lastName":"Doe1","email":"demo@demo.com","createdAt":"2017-12-14T11:10:24.000Z","updatedAt":"2017-12-14T11:10:24.000Z"}
{"id":,"firstName":"John2","lastName":"Doe2","email":"demo@demo.com","createdAt":"2017-12-14T11:10:50.000Z","updatedAt":"2017-12-14T11:10:50.000Z"}
{"id":,"firstName":"John3","lastName":"Doe3","email":"demo@demo.com","createdAt":"2017-12-14T11:10:52.000Z","updatedAt":"2017-12-14T11:10:52.000Z"}

更加简洁的post，get方法例子如下

//定义模型
var UserInfo = sequelize.define("UserInfo", {}, {});
router.post('/post', function (ctx, next) {
  console.log(ctx.request.body);
  let id = ctx.request.body.id || ;
  ctx.body = "you post data:" + JSON.stringify({ id: id });
});

router.get('/search', async function (ctx, next) {
  var userinfos = await UserInfo.findAll();
  ctx.body = JSON.stringify(userinfos);
})

//post 传入的参数  
{
    "id":"",
    "name":"test"
}
[{"key":"Content-Type","value":"application/json","description":"","enabled":true}]

其它操作参见https://github.com/demopark/sequelize-docs-Zh-CN文档介绍。