koa2框架使用

koa是express框架原班人马打造

更轻量级

最重要的是！

不用写回调

需要啥中间件就引用啥

const Koa = require('koa')
const app = new Koa()
const views = require('koa-views')
const json = require('koa-json')
const onerror = require('koa-onerror')
const bodyparser = require('koa-bodyparser')
const logger = require('koa-logger')
const index = require('./routes/index')

// middlewares
app.use(bodyparser({
  enableTypes:['json', 'form', 'text']
}))

app.use(json())
app.use(logger())
app.use(require('koa-static')(__dirname + '/public'))

app.use(views(__dirname + '/views', {
  extension: 'pug'
}))

// 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`)
})

// routes
app.use(index.routes(), index.allowedMethods())
app.use(ship.routes(), ship.allowedMethods())
app.use(others.routes(), others.allowedMethods())
app.use(pscRoute.routes(), pscRoute.allowedMethods())
// error-handling
app.on('error', (err, ctx) => {
  console.error('server error', err, ctx)
});

module.exports = app

把路由添加进去后

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

通过如下办法处理url

router.get('/ship', async (ctx, next) => {
    await ctx.render('index', {
        title: 'Hello ship!'
    })
});
router.post('/ship/info', async (ctx, next) => {
    var reqParam=ctx.request.body;
    const resStr = await shipService.getShipInfo(reqParam);
    ctx.body=resStr;

});

ctx
上下文(Context)

Koa Context 将 node 的 request 和 response 对象封装到单个对象中，为编写 Web 应用程序和 API 提供了许多有用的方法。 这些操作在 HTTP 服务器开发中频繁使用，它们被添加到此级别而不是更高级别的框架，这将强制中间件重新实现此通用功能。


每个 请求都将创建一个 Context，并在中间件中作为接收器引用，或者 ctx 标识符

值得一提的是，，这种不用写回调的写法

基本规则


async 表示这是一个async函数，await只能用在这个函数里面。


await 表示在这里等待promise返回结果了，再继续执行。


await 后面跟着的应该是一个promise对象（当然，其他返回值也没关系，只是会立即执行，不过那样就没有意义了…）

service层

this.getShipInfo = async (reqParam) => {

dao调用

res返回串的处理

}

dao

this.getShipInfo = async(ccsno) =>{
        var sql = "select ~~~~ where id = :id";
        var param = {id:id};
        try {
            var results = await
            oracle.execute(sql,param);
            return oracleutil.getKeyValueDataArr(results);
        }
        catch (e) {
            return "error";
        }
    }

其中oracle执行方法：

exports.execute = async (statement, params=[]) =>
    new Promise((resolve, reject) => {
        oracledb.getConnection(
        ).then(connection => {
            return connection.execute(
                statement, params
            ).then(result => {
                resolve(result);
                return connection.release();
            }).catch(err => {
                日志
                reject(err);
                return connection.release();
            })
        }).catch(err => {
            日志
            reject(err)
        });
    });
exports.getconnection =  async ()=>oracledb.getConnection()