koa2使用es7 的装饰器decorator

npm init

 npm install koa,koa-router;  

├── dist----------------------------------- 编译后的
├── src ----------------------------------- 项目的所有代码
│ ├──config ----------------------------- 配置文件
│ ├──controller ------------------------- 控制器
│ ├──lib -------------------------------- 一些项目的核心文件（如路由的装饰器文件就在这里）
│ ├──logic ------------------------------ 一些数据校验
│ ├──middleware ------------------------- 中间件
│ ├──models------------------------------ 操作数据表相关逻辑代码(根据项目复杂度可以再分Service层)
│ ├──util-------------------------------- 相关的工具文件
│ ├──index.js---------------------------- 项目的入口文件
├── theme --------------------------------- 一些静态文件(上传的图片)
├── .babelrc ------------------------------ babelrc 的相关配置
├── .gitignore ---------------------------- git 的忽略配置文件
├── dev.js -------------------------------- 开发环境的启动文件
├── production.js ------------------------- 生产环境的启动文件

 npm install babel-cli，babel-core,babel-register,babel-plugin-transform-decorators-legacy --save-dev;

{
    "presets": [],
    "plugins": [
        "transform-decorators-legacy"
    ]
}

1. dev.js
require("babel-register");
process.env.NODE_ENV = "development";
require("./src");


2. production.js
process.env.NODE_ENV = "production";
require("./dist");

 "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "build": "babel src  --out-dir dist",
    "dev": "set NODE_ENV=development &&  supervisor  --watch src dev.js",
    "start": "npm run build && set NODE_ENV=production  && supervisor --watch dist production.js",
    "pm2": "pm2 start production.js --name 'wx-node' --env  NODE_ENV='production' --output ./logs/logs-out.log  --error ./logs/logs-error.log  --watch dist"
  },

src/index.js

const koa = require("koa");
const http = require("http");
const App = new koa();

// 定义端口常量
const port = 3000;

App.use(async (ctx,next)=>{
    ctx.body = await "this is koa"
    await next();
})

// 启动服务
var httpApp = http.createServer(App.callback()).listen(port,'0.0.0.0');//获取ip 为ip4 格式(192.168.5.109)，默认是ip6 格式(::ffff:192.168.5.109);
httpApp.on("listening",()=>{
    console.log(`http server start runing in port ${port}...`)
})
App.on("error",(err,ctx)=>{
    console.log("server error: "+err.stack);
    ctx.throw(500, 'server error') 
})

src/lib/decoratorRouter/index.js

const koaRouter = require("koa-router");
const router = new koaRouter(); 
const routerPrefix ="/api"   //定义接口前缀

//声明所有接口的方式的映射，下面会用到
const RequestMethod = {
    GET: 'get',
    POST: 'post',
    PUT: 'put',
    DELETE: 'delete',
    ALL: "all"
}

src/lib/decoratorRouter/index.js
//定义controller 的函数，这是装饰类class 的函数，接受一个参数（和路由前缀并接一起）
function Controller(prefix) {
    router.prefixed =routerPrefix+(prefix ? prefix.replace(/\/+$/g, "") : '');
    //对 类 class 进行拦截操作，返回一个函数，该函数实际接受三个参数（拦截目标targer,目标的key，key 的描述） 
    return (target) => {

        //把路由router 挂载在拦截目标，作为静态属性
        target.router = router;

       //实例化该类 class
        let obj = new target;

       // 获取该实例下的所有实例方法，进行 迭代调用，除了构造函数 和一个前置函数（后面会说得如何实现和作用）
        let actionList = Object.getOwnPropertyDescriptors(target.prototype);
        for (let key in actionList) {
            if (key !== "constructor") {
                var fn = actionList[key].value;
                if (typeof fn == "function" && fn.name != "__before") {
                    fn.call(obj, router, obj);//保证在类中能正确访问this,调用该方法是用call,还有两个参数是 router 和 obj 实例
                }

            }
        }
    }
}    

/src/lib/decoratorRouter/index.js

//该装饰函数接受两个参数，请求url 和请求方式
function Request(option = {url, method}) {

   //拦截该实例方法，参数三个 
    return function (target, value, dec) {

       //声明fn 缓存原来的 函数体 dev.value
        let fn = dec.value;

       //然后重写该函数，参数两个，在 controller 装饰类的时候自动调用转入的两个参数
        dec.value = (routers, targets) => {
    
            //这里，才是真正调用koa-router 路由的时候
            routers[option.method](routers.prefixed + option.url, async (ctx, next) => {
             　　　 //这里写了一个前置函数，判断前置函数存在
                if (target.__before && typeof target.__before == "function") {
                   　 // 如果class 有__before 前置函数，//再默认装饰一次
                    var beforeRes = await target.__before.call(target,ctx, next, target);
                  　　//前置函数如果没有返回内容，继续执行实例方法，否则直接响应 body,不执行实例方法
                    if (!beforeRes) {
                       return await fn.call(target, ctx, next, target)
                    }else{
                        return  ctx.body = await beforeRes
                    }
                } else {
                  // 没有前置函数，直接调回原来的实例函数执行，使用call ，传入的参数就有ctx,next,实例targe
                    await fn.call(target, ctx, next, target)
                }
            })
        }

    }
}    

/src/lib/decoratorRouter/index.js
// post 请求
 function POST(url) {
    return Request({url, method: RequestMethod.POST})
}
 //get 请求
 function GET(url) {
    return Request({url, method: RequestMethod.GET})
}
//PUT 请求
 function PUT(url) {
    return Request({url, method: RequestMethod.PUT})
}
//DEL请求
 function DEL(url) {
    return Request({url, method: RequestMethod.DELETE})
}
 //ALL 请求
 function ALL(url) {
    return Request({url, method: RequestMethod.ALL})
}

module.exports = {
    Controller,POST,GET,PUT,DEL,ALL
}

/src/lib/loadRouter/index.js

const fs = require("fs");
const {resolve} = require("path")
//这里很重要，区别环境变量，确定调用是 dist/controller （编译后），还是调用 src/controller （开发）
let entryPath = process.env.NODE_ENV==="development"?"src":"dist"; 
console.log(process.env.NODE_ENV+"环境:执行目录"+entryPath)//这是controller 的入口根目录
let controllerPath = resolve(entryPath,'controller');
//对外导出一个函数，并接收app 实例作为参数，
module.exports = (App)=>{
    let  loadCtroller = (rootPaths)=>{
        try {
            var allfile = fs.readdirSync(rootPaths);  //加载目录下的所有文件进行遍历
            allfile.forEach((file)=>{
                var filePath = resolve(rootPaths,file)// 获取遍历文件的路径
　　　　　　　　　　
                if(fs.lstatSync(filePath).isDirectory()){ //判断该文件是否是文件夹，如果是递归继续遍历读取文件
                    loadCtroller(filePath)
                }else{
                 //如果是文件就使用require 导入，（controller下文件都是对外导出的class),在使用 @controller 装饰函数的时候,将koa-router 的实例作为装饰对象class 的静态属性 　
　　　　　　        let r = require(filePath);
                  if(r&&r.router&&r.router.routes){ //如果有koa-routr 的实例说明装饰成功，直接调用app.use() 
                      try {
                        App
                        .use(r.router.routes())
                      } catch (error) {
                          console.log(filePath)
                      }
                  }else{
                      // console.log("miss routes:--filename:"+filePath)
                  }
                }
            }) 
        } catch (error) {
            console.log(error)
            console.log("no such file or dir :---- "+rootPaths)
        } 
    }
    //调用自动加载路由
    loadCtroller(controllerPath);

}

const koa = require("koa");
const http = require("http");
const App = new koa();

// 定义端口常量
const port = 3000;


require("./lib/loadRouter/index")(App) // 载入自动加载路由文件

// 启动服务
var httpApp = http.createServer(App.callback()).listen(port,'0.0.0.0');//获取ip 为ip4 格式(192.168.5.109)，默认是ip6 格式(::ffff:192.168.5.109);
httpApp.on("listening",()=>{
    console.log(`http server start runing in port ${port}...`)
})
App.on("error",(err,ctx)=>{
    console.log("server error: "+err.stack);
    ctx.throw(500, 'server error') 
})

/src/controller/index.js

const {Controller,GET,POST} = require("../lib/decoratorRouter")

 //访问路径 ：路由前缀 + controller 参数 + 请求方式的参数 => 域名:端口/api/index/add
@Controller("/index")
class index{

    @GET("/")
    async index(ctx,next){
         ctx.body = await "this is index"
    }
    @POST("/add")  
    async add(ctx,next){
         ctx.body = await "this is add"
    }
}
module.exports = index;