Koa源码解析&手写

本文基于koa 3.0.0-alpha.1版本源码进行分析

由于koa的源码量非常少，但是体现的思想非常经典和难以记忆，如果突然要手写koa代码，可能还不一定能很快写出来，因此本文将集中于如何理解以及记忆koa的代码

本文一些代码块为了演示方便，可能有一些语法排列错误，因此本文所有代码均可以视为伪代码

1. 文章内容

  1. 从0到1推导koa 3.0.0-alpha.1版本源码的实现，一步一步完善简化版koa的手写逻辑
  2. 分析常用中间件koa-router的源码以及进行对应的手写
  3. 分析常用中间件koa-bodyparser的源码以及进行对应的手写

2. 核心代码分析&手写

2.1 koa-compose

const Koa = require('koa');
const app = new Koa();

app.use(async (ctx, next) => {
    console.log("中间件1 start");
    await next();
    console.log("中间件1 end");
});
app.use(async (ctx, next) => {
    console.log("中间件2 start");
    await next();
    console.log("中间件2 end");
});
app.use(async (ctx, next) => {
    console.log("中间件3 start");
    await next();
    console.log("中间件3 end");
});
app.listen(3000);

上面代码块中间件运行流程如下所示

上面的运行流程看起来就跟我们平时开发不太一样，我们可以看一个相似的场景，比如下面

  • 我们在fn1()中执行一系列的业务逻辑
  • 但是我们在fn1()遇到了await fn2()，因此我们得等待fn2()执行完毕后才能继续后面的业务逻辑
function fn1() {
    console.log("fn1执行业务逻辑1");
    await fn2();
    console.log("fn1执行业务逻辑2")
}
async function fn2() {
    console.log("fn2执行业务逻辑1");
}

我们将fn2作为参数传入

async function fn2() {
    console.log("fn2执行业务逻辑1");
}
function fn1(fn2) {
    console.log("fn1执行业务逻辑1");
    await fn2();
    console.log("fn1执行业务逻辑2")
}

如果我们有fn3、fn4呢？

async function fn1(fn2) {
    console.log("fn1执行业务逻辑1");
    await fn2();
    console.log("fn1执行业务逻辑2")
}
async function fn2(fn3) {
    console.log("fn2执行业务逻辑1");
    await fn3();
    console.log("fn2执行业务逻辑2")
}
async function fn3(fn4) {
    console.log("fn3执行业务逻辑1");
    await fn4();
    console.log("fn3执行业务逻辑2")
}
async function fn4() {
    console.log("fn4执行业务逻辑1");
    console.log("fn4执行业务逻辑2")
}

那如果我们还有fn5、fn6....呢？

我们使用怎样的逻辑进行这种function的嵌套？

我们可以从上面代码发现，每一个fnX()传递的都是上一个fn(X+1)()

2.1.1 使用middleware遍历所有fn

我们可以先使用一个数组进行fn的添加

middleware.push(fn);

当我们取出一个fn时，我们应该传入下一个fn，即

let fn = middleware[i];
fn(middleware[i+1]);

如果我们想要顺序传入context

let fn = middleware[i];
fn(context, middleware[i+1]);

使用middleware整合上面的逻辑，如下面所示

  • 我们使用app.use((ctx, next))传入的next()需要强制返回一个Promise，因为它可以使用await，因此我们使用Promise.resolve()包裹fn()返回的值，防止返回的不是Promise
  • 在调用fn()的时候，会传入下一个中间件作为第二个参数：middleware[i + 1]
let middleware = [];
let context = {};

let app = {
    use(fn) {
        middleware.push(fn);
    },
    listen(...args) {
        this.callback();
    },
    callback() {
        // 要求每一个fn返回都是一个Promise
        function dispatch(i) {
            let fn = middleware[i];
            // 可能返回只是一个普通的数据，因此需要使用Promise.resolve()进行包裹返回一个Promise数据
            return Promise.resolve(fn(context, middleware[i + 1]));
        }
        return dispatch(0);
    }
};
app.use(async (ctx, next) => {
    console.log("fn1执行业务逻辑1");
    await next();
    console.log("fn1执行业务逻辑2")
});
app.use(async (ctx, next) => {
    console.log("fn2执行业务逻辑1");
    console.log("fn2执行业务逻辑2")
});
app.listen(200);

2.1.2 链式调用

async function fn1(fn2) {
    console.log("fn1执行业务逻辑1");
    await fn2();
    console.log("fn1执行业务逻辑2")
}
async function fn2(fn3) {
    console.log("fn2执行业务逻辑1");
    await fn3();
    console.log("fn2执行业务逻辑2")
}
async function fn3() {
    console.log("fn3执行业务逻辑1");
    console.log("fn3执行业务逻辑2")
}
我们如何实现fn1->fn2->fn3的链式调用呢？ 
fn1(fn2(fn3))

回到我们上面实现的koa源码

let middleware = [];
let context = {};

let app = {
    use(fn) {
        middleware.push(fn);
    },
    listen(...args) {
        this.callback();
    },
    callback() {
        // 要求每一个fn返回都是一个Promise
        function dispatch(i) {
            let fn = middleware[i];
            // 可能返回只是一个普通的数据，因此需要使用Promise.resolve()进行包裹返回一个Promise数据
            return Promise.resolve(fn(context, middleware[i + 1]));
        }
        return dispatch(0);
    }
};
app.use(async (ctx, next) => {
    console.log("fn1执行业务逻辑1");
    await next();
    console.log("fn1执行业务逻辑2")
});
app.use(async (ctx, next) => {
    console.log("fn2执行业务逻辑1");
    console.log("fn2执行业务逻辑2")
});
app.listen(200);

如上面所示，我们执行了fn1(context, fn2)，但是我们fn2()并没有传入fn3，这导致了链式调用被中断了，而且fn2()也不一定会返回Promise，因此我们需要对下面代码进行调整

let middleware = [];
let context = {};

let app = {
    use(fn) {
        middleware.push(fn);
    },
    listen(...args) {
        this.callback();
    },
    callback() {
        // 要求每一个fn返回都是一个Promise
        function dispatch(i) {
            let fn = middleware[i];
            // 可能返回只是一个普通的数据，因此需要使用Promise.resolve()进行包裹返回一个Promise数据
            return Promise.resolve(fn(context, dispatch(i + 1)));
        }
        return dispatch(0);
    }
};
app.use(async (ctx, next) => {
    console.log("fn1执行业务逻辑1");
    await next();
    console.log("fn1执行业务逻辑2")
});
app.use(async (ctx, next) => {
    console.log("fn2执行业务逻辑1");
      await next();
    console.log("fn2执行业务逻辑2")
});
app.listen(200);

fn(context, middleware[i + 1])调整为fn(context, dispatch(i + 1))
这样我们就可以实现

  • fn2()返回的是Promise.resolve()，无论fn2()返回什么，都是一个Promise
  • fn2(context, dispatch(i + 1))的第二个参数传入了fn3，并且fn3是一个Promise

2.1.3 细节优化

2.1.3.1 app.use返回this

app.use()返回自己本身，可以使用链式调用

let app = {
    use(fn) {
        middleware.push(fn);
        return this;
    }
}
app.use(async (ctx, next) => {
    console.log("fn1执行业务逻辑1");
    await next();
    console.log("fn1执行业务逻辑2")
}).use(async (ctx, next) => {
    console.log("fn2执行业务逻辑1");
    console.log("fn2执行业务逻辑2")
});
2.1.3.2 dispatch()返回方法

dispatch(i + 1)返回的是一个执行完毕的Promise状态，不是一个方法，需要改成bind

let middleware = [];
let context = {};

let app = {
    use(fn) {
        middleware.push(fn);
      return this;
    },
    listen(...args) {
        this.callback();
    },
    callback() {
        // 要求每一个fn返回都是一个Promise
        function dispatch(i) {
            let fn = middleware[i];
            // 可能返回只是一个普通的数据，因此需要使用Promise.resolve()进行包裹返回一个Promise数据
            return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
        }
        return dispatch(0);
    }
};
app.use(async (ctx, next) => {
    console.log("fn1执行业务逻辑1");
    await next();
    console.log("fn1执行业务逻辑2")
});
app.use(async (ctx, next) => {
    console.log("fn2执行业务逻辑1");
      await next();
    console.log("fn2执行业务逻辑2")
});
app.listen(200);
2.1.3.3 最后一个中间件返回空的Promise.resolve

最后一个中间件调用next()时没有执行的方法，应该直接返回一个空的方法，比如上面代码中

  • console.log("fn2执行业务逻辑1")
  • await next(): 此时的next()应该是一个空的Promise方法
  • console.log("fn2执行业务逻辑2")
let middleware = [];
let context = {};

let app = {
    use(fn) {
        middleware.push(fn);
        return this;
    },
    listen(...args) {
        this.callback();
    },
    callback() {
        // 要求每一个fn返回都是一个Promise
        function dispatch(i) {
            let fn = middleware[i];
            if (i === middleware.length) {
                return Promise.resolve();
            }
            // 可能返回只是一个普通的数据，因此需要使用Promise.resolve()进行包裹返回一个Promise数据
            return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
        }
        return dispatch(0);
    }
};
app.use(async (ctx, next) => {
    console.log("fn1执行业务逻辑1");
    await next();
    console.log("fn1执行业务逻辑2")
});
app.use(async (ctx, next) => {
    console.log("fn2执行业务逻辑1");
    await next();
    console.log("fn2执行业务逻辑2")
});
app.listen(200);
2.1.3.4 阻止中间件中重复调用next()

阻止一个中间件重复调用next()方法，使用index记录当前的i，如果发现i<=index，说明重复调用了某一个中间件的next()方法

let middleware = [];
let context = {};

let app = {
    use(fn) {
        middleware.push(fn);
        return this;
    },
    listen(...args) {
        this.callback();
    },
    callback() {
        // 要求每一个fn返回都是一个Promise
        let index = -1;
        function dispatch(i) {
            if (i <= index) {
                return new Promise.reject(new Error("next()重复调用多次"));
            }
            index = i;
            let fn = middleware[i];
            if (i === middleware.length) {
                return Promise.resolve();
            }
            // 可能返回只是一个普通的数据，因此需要使用Promise.resolve()进行包裹返回一个Promise数据
            return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
        }
        return dispatch(0);
    }
};
app.use(async (ctx, next) => {
    console.log("fn1执行业务逻辑1");
    await next();
   await next();
    console.log("fn1执行业务逻辑2")
});
app.use(async (ctx, next) => {
    console.log("fn2执行业务逻辑1");
    await next();
    console.log("fn2执行业务逻辑2")
});
app.listen(200);
2.1.3.5 完善错误处理逻辑
  • 重复调用next()抛出错误
  • 执行fn()过程中出错

将dispatch()的外层再包裹一个新的function()，然后我们就可以使用这个function()进行统一的then()和catch()处理，即下面代码中的

  • let fn = compose(this.middleware)
  • fn().then(() => {}).catch(err => {})
function compose(middleware) {
    // 返回也是一个Promise，可能是Promise.resolve()，也有可能是Promise.reject()
    return function (context) {
        // 要求每一个fn返回都是一个Promise
        let index = -1;
        function dispatch(i) {
            if (i <= index) {
                return Promise.reject(new Error("next()重复调用多次"));
            }
            index = i;
            let fn = middleware[i];
            if (i === middleware.length) {
                return Promise.resolve();
            }
            try {
                // 可能返回只是一个普通的数据，因此需要使用Promise.resolve()进行包裹返回一个Promise数据
                return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
            } catch (err) {
                return Promise.reject(err)
            }

        }
        return dispatch(0);
    }

}

let app = {
    middleware: [],
    use(fn) {
        this.middleware.push(fn);
        return this;
    },
    listen(...args) {
        this.callback();
    },
    callback() {
        let fn = compose(this.middleware);
        let context = {};
        fn(context).then(() => {
            // 正常执行最终触发
            console.log("fn执行完毕!");
        }).catch(error => {
            console.error("fn执行错误", error);
        });
    }
};
app.use(async (ctx, next) => {
    console.log("fn1执行业务逻辑1");
    await next();
    await next();
    console.log("fn1执行业务逻辑2")
});
app.use(async (ctx, next) => {
    console.log("fn2执行业务逻辑1");
    await next();
    console.log("fn2执行业务逻辑2")
});
app.listen(200);

运行上面代码，得到的结果为：
Koa源码解析&手写_第1张图片

2.1.3.6 兼容compose传入next()方法

compose()返回的function(context)增加传入参数next，可以在外部进行定义传入，然后判断

  • 当i等于middleware.length时，middleware[i]肯定为空，判断最后一个next()是否为空
  • 如果最后一个next()不为空，则继续执行最后一次next()
  • 如果最后一个next()为空，则直接返回空的Promise.resolve，跟上面我们处理i等于middleware.length时的逻辑一样
function compose(middleware) {
    // 返回也是一个Promise，可能是Promise.resolve()，也有可能是Promise.reject()
    return function (context, next) {
        // 要求每一个fn返回都是一个Promise
        let index = -1;
        function dispatch(i) {
            if (i <= index) {
                return Promise.reject(new Error("next()重复调用多次"));
            }
            index = i;
            let fn = middleware[i];
            if (i === middleware.length) {
                // middleware[i]肯定为空，判断最后一个next()是否为空
                // 如果不为空，则继续执行最后一次
                // 如果为空，则返回Promise.resolve()
                fn = next;
            }
            if (!fn) {
                return Promise.resolve();
            }
            try {
                // 可能返回只是一个普通的数据，因此需要使用Promise.resolve()进行包裹返回一个Promise数据
                return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
            } catch (err) {
                return Promise.reject(err)
            }

        }
        return dispatch(0);
    }

}

let app = {
    middleware: [],
    use(fn) {
        this.middleware.push(fn);
        return this;
    },
    listen(...args) {
        this.callback();
    },
    callback() {
        let fn = compose(this.middleware);
        let context = {};
        const next = function () {
            console.log("最后一个next()!");
        }
        fn(context, next).then(() => {
            // 正常执行最终触发
            console.log("fn执行完毕!");
        }).catch(error => {
            console.error("fn执行错误", error);
        });
    }
};
app.use(async (ctx, next) => {
    console.log("fn1执行业务逻辑1");
    await next();
    await next();
    console.log("fn1执行业务逻辑2")
});
app.use(async (ctx, next) => {
    console.log("fn2执行业务逻辑1");
    await next();
    console.log("fn2执行业务逻辑2")
});
app.listen(200);
2.1.3.7 处理middleware不为数组时错误的抛出
function compose(middleware) {
    if (!Array.isArray(middleware)) throw new TypeError('Middleware stack must be an array!')
    for (const fn of middleware) {
        if (typeof fn !== 'function') throw new TypeError('Middleware must be composed of functions!')
    }
    // 返回也是一个Promise，可能是Promise.resolve()，也有可能是Promise.reject()
    return function (context, next) {
        // 要求每一个fn返回都是一个Promise
        let index = -1;
        function dispatch(i) {
            if (i <= index) {
                return Promise.reject(new Error("next()重复调用多次"));
            }
            index = i;
            let fn = middleware[i];
            if (i === middleware.length) {
                // middleware[i]肯定为空，判断最后一个next()是否为空
                // 如果不为空，则继续执行最后一次
                // 如果为空，则返回Promise.resolve()
                fn = next;
            }
            if (!next) {
                return Promise.resolve();
            }
            try {
                // 可能返回只是一个普通的数据，因此需要使用Promise.resolve()进行包裹返回一个Promise数据
                return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
            } catch (err) {
                return Promise.reject(err)
            }

        }
        return dispatch(0);
    }

}

let app = {
    middleware: [],
    use(fn) {
        this.middleware.push(fn);
        return this;
    },
    listen(...args) {
        this.callback();
    },
    callback() {
        let fn = compose(this.middleware);
        let context = {};
        const next = function () {
            console.log("最后一个next()!");
        }
        fn(context, next).then(() => {
            // 正常执行最终触发
            console.log("fn执行完毕!");
        }).catch(error => {
            console.error("fn执行错误", error);
        });
    }
};
app.use(async (ctx, next) => {
    console.log("fn1执行业务逻辑1");
    await next();
    await next();
    console.log("fn1执行业务逻辑2")
});
app.use(async (ctx, next) => {
    console.log("fn2执行业务逻辑1");
    await next();
    console.log("fn2执行业务逻辑2")
});
app.listen(200);
至此，我们已经完全实现了官方koa-compose的完整代码！

2.2 Node.js原生http模块

Koa是基于中间件模式的HTTP服务框架，底层原理就是封装了Node.js的http原生模块

在上面实现koa-compose中间件的基础上，我们增加Node.js的http原生模块，基本就是Koa的核心代码的实现

2.2.1 原生代码示例

const http = require('http');
const server = http.createServer((req, res)=> {
  res.end(`this page url = ${req.url}`);
});
server.listen(3001, function() {
  console.log("the server is started at port 3001")
})

2.2.2 增加原生http模块的相关代码

完善listen()和callback()的相关方法，增加原生http模块的相关代码

function compose(middleware) {
    if (!Array.isArray(middleware)) throw new TypeError('Middleware stack must be an array!')
    for (const fn of middleware) {
        if (typeof fn !== 'function') throw new TypeError('Middleware must be composed of functions!')
    }
    // 返回也是一个Promise，可能是Promise.resolve()，也有可能是Promise.reject()
    return function (context, next) {
        // 要求每一个fn返回都是一个Promise
        let index = -1;
        function dispatch(i) {
            if (i <= index) {
                return Promise.reject(new Error("next()重复调用多次"));
            }
            index = i;
            let fn = middleware[i];
            if (i === middleware.length) {
                // middleware[i]肯定为空，判断最后一个next()是否为空
                // 如果不为空，则继续执行最后一次
                // 如果为空，则返回Promise.resolve()
                fn = next;
            }
            if (!next) {
                return Promise.resolve();
            }
            try {
                // 可能返回只是一个普通的数据，因此需要使用Promise.resolve()进行包裹返回一个Promise数据
                return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
            } catch (err) {
                return Promise.reject(err)
            }

        }
        return dispatch(0);
    }

}

let app = {
    middleware: [],
    use(fn) {
        this.middleware.push(fn);
        return this;
    },
    listen(...args) {
        const server = http.createServer(this.callback());
        return server.listen(...args);
    },
    callback() {
        let fn = compose(this.middleware);
        return (req, res) => {
            let context = {};
            this.handleRequest(context, fn);
        }
    },
    handleRequest(context, fn) {
        const next = function () {
            console.log("最后一个next()!");
        }
        fn(context, next).then(() => {
            // 正常执行最终触发
            console.log("fn执行完毕!");
        }).catch(error => {
            console.error("fn执行错误", error);
        });
    }
};
app.use(async (ctx, next) => {
    console.log("fn1执行业务逻辑1");
    await next();
    await next();
    console.log("fn1执行业务逻辑2")
});
app.use(async (ctx, next) => {
    console.log("fn2执行业务逻辑1");
    await next();
    console.log("fn2执行业务逻辑2")
});
app.listen(200);

2.3 初始化context

将app={}的形式完善为class Koa的形式，然后在构造函数中初始化context、request、response的初始化，在callback()进行http.createServer()回调函数req和res的赋值

createContext(req, res) {
  const context = Object.create(this.context);
  const request = (context.request = Object.create(this.request));
  const response = (context.response = Object.create(this.response));
  context.app = request.app = response.app = this;
  context.req = request.req = response.req = req;
  context.res = request.res = response.res = res;
  request.ctx = response.ctx = context;
  request.response = response;
  response.request = request;
  context.originalUrl = request.originalUrl = req.url;
  context.state = {};
  return context;
}

完整代码如下所示

const context = require("./context.js");
const request = require("./request.js");
const response = require("./response.js");

function compose(middleware) {
  if (!Array.isArray(middleware)) throw new TypeError("Middleware stack must be an array!");
  for (const fn of middleware) {
    if (typeof fn !== "function") throw new TypeError("Middleware must be composed of functions!");
  }
  // 返回也是一个Promise，可能是Promise.resolve()，也有可能是Promise.reject()
  return function (context, next) {
    // 要求每一个fn返回都是一个Promise
    let index = -1;
    function dispatch(i) {
      if (i <= index) {
        return Promise.reject(new Error("next()重复调用多次"));
      }
      index = i;
      let fn = middleware[i];
      if (i === middleware.length) {
        // middleware[i]肯定为空，判断最后一个next()是否为空
        // 如果不为空，则继续执行最后一次
        // 如果为空，则返回Promise.resolve()
        fn = next;
      }
      if (!next) {
        return Promise.resolve();
      }
      try {
        // 可能返回只是一个普通的数据，因此需要使用Promise.resolve()进行包裹返回一个Promise数据
        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
      } catch (err) {
        return Promise.reject(err);
      }
    }
    return dispatch(0);
  };
}

class Koa {
  constructor() {
    this.middleware = [];
    this.context = Object.create(context);
    this.request = Object.create(request);
    this.response = Object.create(response);
  }

  createContext(req, res) {
    const context = Object.create(this.context);
    const request = (context.request = Object.create(this.request));
    const response = (context.response = Object.create(this.response));
    context.app = request.app = response.app = this;
    context.req = request.req = response.req = req;
    context.res = request.res = response.res = res;
    request.ctx = response.ctx = context;
    request.response = response;
    response.request = request;
    context.originalUrl = request.originalUrl = req.url;
    context.state = {};
    return context;
  }

  use(fn) {
    this.middleware.push(fn);
    return this;
  }

  listen(...args) {
    const server = http.createServer(this.callback());
    return server.listen(...args);
  }

  callback() {
    let fn = compose(this.middleware);
    return (req, res) => {
      let context = this.createContext(req, res);
      this.handleRequest(context, fn);
    };
  }

  handleRequest(context, fn) {
    const next = function () {
      console.log("最后一个next()!");
    };
    fn(context, next)
      .then(() => {
        // 正常执行最终触发
        console.log("fn执行完毕!");
      })
      .catch((error) => {
        console.error("fn执行错误", error);
      });
  }
}

const app = new Koa();
app.use(async (ctx, next) => {
  console.log("fn1执行业务逻辑1");
  await next();
  await next();
  console.log("fn1执行业务逻辑2");
});
app.use(async (ctx, next) => {
  console.log("fn2执行业务逻辑1");
  await next();
  console.log("fn2执行业务逻辑2");
});
app.listen(200);

2.4 完善响应数据的逻辑

由上面初始化context的代码可以知道，我们已经将http原生模块的req和res都放入到context中，因此我们在执行完毕中间件后，我们应该对context.res进行处理，返回对应的值

handleRequest(context, fn) {
    const next = function () {
        console.log("最后一个next()!");
    };
    const handleResponse = () => {
        return this.handleResponse(context);
    };
    fn(context, next)
        .then(handleResponse)
        .catch((error) => {
            console.error("fn执行错误", error);
        });
}
handleResponse(ctx) {
    const res = ctx.res;
    let body = ctx.body;
    if (!body) {
        return res.end();
    }

    if (typeof body !== "string") {
        body = JSON.stringify(body);
    }

    res.end(body);
}
至此，我们完成了一个简化版本的Koa，完整代码放在github mini-koa

3. 常见中间件分析&手写

3.1 koa-router

3.1.1 不使用koa-router

在不使用koa-router中间件时，我们需要手动根据ctx.request.url去判断路由，如下面代码所示

const Koa = require("koa");
const fs = require("fs");
const app = new Koa();

function readFile(path) {
    return new Promise((resolve, reject) => {
        let htmlUrl = `../front/${path}`;
        fs.readFile(htmlUrl, "utf-8", (err, data) => {
            if (err) {
                reject(err);
            } else {
                resolve(data);
            }
        });
    });
}

async function parseUrl(url) {
    let base = "404.html";
    switch (url) {
        case "/":
            base = "index.html";
            break;
        case "/login.html":
            base = "login.html";
            break;
        case "/home.html":
            base = "home.html";
            break;
    }
    // 从本地读取出该路径下html文件的内容，然后返回给客户端
    const data = await readFile(base);
    return data;
}

app.use(async (ctx) => {
    let url = ctx.request.url;
    // 判断这个url是哪一个请求
    const htmlContent = await parseUrl(url);
    ctx.status = 200;
    ctx.body = htmlContent;
});
app.listen(3000);
console.log("[demo] route is starting at port 3000");

因此我们手写koa-router时，我们需要关注几个问题：

  • 根据ctx.path判断是否符合注册的路由，如果符合，则触发注册的方法
  • 我们需要根据path、methods进行对应数据结构的构建

3.1.2 使用koa-router的具体示例

const app = new Koa();
const router = new Router();
router.get("/", (ctx, next) => {
  // ctx.router available
});
router.get("/home", (ctx, next) => {
    // ctx.router available
});
app.use(router.routes());

3.1.3 根据示例实现koa-router

根据methods初始化所有方法，形成this["get"]、this["put"]的数据结构，提供给外部调用注册路由

当有新的请求发生时，会触发中间件的逻辑执行，会根据目前ctx.path和ctx.method去寻找之前是否有注册过的路径，如果有则触发注册路径的callback进行逻辑的执行

function Router(opts) {
  this.register = function (path, methods, callback, opts) {
    this.stack.push({
      path,
      methods,
      middleware: callback,
      opts,
    });
    return this;
  };

  this.routes = function () {
    // 返回所有注册的路由

    return async (ctx, next) => {
      // 每次执行中间件时，判断是否有符合register()的路由

      const path = ctx.path;
      const method = ctx.method.toUpperCase();

      let callback;

      for (const item of this.stack) {
        if (path === item.path && item.methods.indexOf(method) >= 0) {
          // 找到对应的路由
          callback = item.middleware;
          break;
        }
      }

      if (callback) {
        callback(ctx, next);
        return;
      }
      await next();
    };
  };
  
  this.opts = opts || {};
  this.methods = this.opts.methods || ["HEAD", "OPTIONS", "GET", "PUT", "PATCH", "POST", "DELETE"];
  this.stack = [];

  // 根据methods初始化所有方法，形成this["get"]、this["put"]的数据结构

  for (const _method of this.methods) {
    this[_method.toLowerCase()] = this[_method] = function (path, callback) {
      this.register(path, [_method], callback);
    };
  }
}

3.2 koa-bodyparser

该中间件可以简化请求体的解析流程

当我们不使用koa-bodyparser时，如下面所示

3.2.1 不使用koa-bodyparser

GET请求

  1. query是格式化好的参数对象，比如query={a:1, b:2}
  2. querystring是请求字符串，比如querystring="a=1&b=2"
let request = ctx.request;
let query = request.query;
let queryString = request.querystring;
// 也可以直接省略request，const {query, querystring} = request

POST请求
没有封装具体的方法，需要手动解析ctx.req这个原生的node.js对象
如下面例子所示，ctx.req获取到formData为"userName=22&nickName=22323&email=32323"
我们需要将formData解析为{userName: 22, nickName: 22323, email: 32323}

home.post("b", async (ctx) => {
  const body = await parseRequestPostData(ctx);
  ctx.body = body;
});
async function parseRequestPostData(ctx) {
  return new Promise((resolve, reject) => {
    const req = ctx.req;
    let postData = "";
    req.addListener("data", (data) => {
      postData = postData + data;
    });

    req.addListener("end", () => {
      if (postData) {
        let parseData = transStringToObject(postData);
        resolve(parseData);
      } else {
        resolve("没有数据");
      }
    });
  });
}
async function transStringToObject(data) {
  let result = {};
  let dataList = data.split("&");
  for (let [index, queryString] of dataList.entries()) {
    let itemList = queryString.split("=");
    result[itemList[0]] = itemList[1];
  }
  return result;
}

3.2.2 使用koa-bodyparser的具体示例

const Koa = require("koa");
const fs = require("fs");
const app = new Koa();

const Router = require("koa-router");
const bodyParser = require("koa-bodyparser");

// post请求参数解析示例
home.get("form", async (ctx) => {
    let html = `
      
koa2 request post demo

      

        
userName

        

        
nickName

        

        
email

        

        
      

    `;
    ctx.body = html;
});
home.post("b", async (ctx) => {
    // 普通解析逻辑
    // const body = await parseRequestPostData(ctx);
    // ctx.body = body;

    // 使用koa-bodyparser会自动解析表单的数据然后放在ctx.request.body中
    let postData = ctx.request.body;
    ctx.body = postData;
});

let router = new Router();
router.use("/", home.routes()); //http://localhost:3000

app.use(bodyParser()); // 这个中间件的注册应该放在router之前！
app.use(router.routes());

app.listen(3002);

3.2.3 根据示例实现koa-bodyparser

当ctx.method是POST请求时，自动解析ctx.request.body，主要分为：

  • form类型
  • json类型
  • text类型

根据不同的类型调用不同的解析方法，然后赋值给ctx.request.body

/**
 * 注册对应的监听方法，进行request流数据的读取
 * @param req
 */
function readStreamBody(req) {
  return new Promise((resolve, reject) => {
    let postData = "";
    req.addListener("data", (data) => {
      postData = postData + data;
    });

    req.addListener("end", () => {
      if (postData) {
        resolve(postData);
      } else {
        resolve("没有数据");
      }
    });
  });
}

async function parseQuery(data) {
  let result = {};
  let dataList = data.split("&");
  for (let [index, queryString] of dataList.entries()) {
    let itemList = queryString.split("=");
    result[itemList[0]] = itemList[1];
  }
  return result;
}

async function parseJSON(ctx, data) {
  let result = {};
  try {
    result = JSON.parse(data);
  } catch (e) {
    ctx.throw(500, e);
  }
  return result;
}

function bodyParser() {
  return async (ctx, next) => {
    if (!ctx.request.body && ctx.method === "POST") {
      let body = await readStreamBody(ctx.request.req);
      // With Content-Type: text/html; charset=utf-8
      // this.is('html'); // => 'html'
      // this.is('text/html'); // => 'text/html'
      // this.is('text/', 'application/json'); // => 'text/html'
      //
      // When Content-Type is application/json
      // this.is('json', 'urlencoded'); // => 'json'
      // this.is('application/json'); // => 'application/json'
      // this.is('html', 'application/'); // => 'application/json'
      //
      // this.is('html'); // => false
      let result;
      if (ctx.request.is("application/x-www-form-urlencoded")) {
        result = await parseQuery(body);
      } else if (ctx.request.is("application/json")) {
        result = await parseJSON(ctx, body);
      } else if (ctx.request.is("text/plain")) {
        result = body;
      }
      ctx.request.body = result;
    }
    await next();
  };
}

module.exports = bodyParser;

参考

  1. Koa.js 设计模式-学习笔记
  2. Koa2进阶学习笔记

你可能感兴趣的:(源码node.jskoa)

  • 手把手教你企业微信SCRM源码下载和私有化部署教程 MoChat-1号 php微信微信公众平台微信开放平台
    服务器要求MoChat对系统环境有一些要求，仅可运行于Linux和Mac环境下，但由于Docker虚拟化技术的发展，在Windows下也可以通过DockerforWindows来作为运行环境，通常来说Mac环境下，我们更推荐本地环境部署，以避免Docker共享磁盘缓慢导致MoChat启动速度慢的问题。提示MoChat基于Docker-compose方式的安装视频https://www.bilibi
  • 计算机毕业设计Node.js+Vue基于Java的医院预约挂号系统(程序+源码+LW+部署) Nodejs洋洋 程序 javavue.js课程设计
    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：Node.js+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：Express框架+Node.js+Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是Nodejs最新版，我们在这个版本上开发的。其他版本理论上也可
  • Java高并发编程详解系列-深入理解Thread构造 nihui123 高并发Java高并发Java高并发
    上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范  从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
  • 【QT教程】QT6硬件图形界面编程 QT硬件编程 QT性能优化QT原理源码QT界面美化 qtqt6.3qt5c++QT教程
    QT6硬件图形界面编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件图形界面编程概述1.1QT6硬件图形界面编程简介1.1.1QT6硬件
  • [HarmonyOS Next示例代码] 鸿蒙UI开发 - 组件动态创建 xiaohai_09 HarmonyOSNextUI开发harmonyos鸿蒙
    鸿蒙UI开发-组件动态创建源码下载地址介绍本示例介绍了在声明式UI中实现组件动态创建的方法效果图预览主页面广告关闭弹窗使用说明进入应用后，广告组件随即被动态创建。其分为两种，分别为图片广告与视频广告。实现思路构建广告组件。源码参考AdBuilder.ets。模拟从云端初始化卡片列表，根据云端数据生成普通卡片对象和广告卡片对象。源码参考代码可参考MainPage.ets中的aboutToAppear
  • 基于HTML+JS+CSS+Echarts实现的设备环境监测可视化平台前端整套模板 abments 实用小工具javascript前端html
    效果图基于HTML+JS+CSS+Echarts实现的设备环境监测可视化平台前端整套模板。可用过修改源码快速完成需求。源码结构下载地址
  • 工程项目管理系统源码与Spring Cloud：实现高效系统管理与二次开发 微服务技术分享 springcloudjava工程项目管理系统源码
    随着企业规模的不断扩大和业务的快速发展，传统的工程项目管理方式已经无法满足现代企业的需求。为了提高工程管理效率、减轻劳动强度、提高信息处理速度和准确性，企业需要借助先进的数字化技术进行转型。本文将介绍一款采用SpringCloud+SpringBoot+Mybatis技术框架的工程项目管理系统，该系统涵盖了项目管理、合同管理、预警管理、竣工管理、质量管理等多个方面，通过数据字典、编码管理、用户管理
  • Spring Cloud Alibaba的Java CRM客户关系管理系统源码 微服务技术分享 javaCRM客户关系管理系统源码
    ERP（EnterpriseResourcePlanning，企业资源计划）软件是一种集成的管理平台，它将企业的所有业务流程，包括采购、销售、库存、财务等，整合到一个统一的系统中。这种整合不仅提高了工作效率，还增强了数据的准确性和实时性。在当今快速发展的商业环境中，ERP软件已经成为企业不可或缺的工具。本文将详细介绍ERP软件的主要模块及其功能，帮助读者更好地理解ERP软件如何助力企业实现信息化管
  • Android SurfaceTexture和GLSurfaceView做Camera预览 小小攻城师 AndroidSurfaceTextureGLSurfaceViewSurfaceTextureopenGopenGL
    GLSurfaceView是OpenGL中的一个类，也是可以预览Camera的，而且在预览Camera上有其独到之处。独到之处在哪？当使用Surfaceview无能为力、痛不欲生时就只有使用GLSurfaceView了，它能够真正做到让Camera的数据和显示分离，所以搞明白了这个，像Camera只开预览不显示这都是小菜，妥妥的。Android4.0的自带Camera源码是用SurfaceView
  • [附源码]SSM计算机毕业设计游戏账号交易平台JAVA 计算机程序源码 java游戏mysql
    项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
  • Redisson分布式锁实现原理和使用 牧竹子 springboot#redisRedissonredis
    常见的锁内存锁lock,synchronize分布式锁redis，zookeeper实现Redisson基于redis实现了Lock接口的分布式集群锁，是可重入锁，功能强大，源码复杂，比redis单机模式分布式锁可靠，稳定性更高，支持集群模式，支持锁根据业务时长自动延迟释放redis普通分布式锁存在一定的缺陷——它加锁只作用在一个Redis节点上，如果通过sentinel和cluster保证高可用
  • 【Vue3源码实现】Ref isRef unRef proxyRefs实现 ZhaiMou vue.jsjavascript前端数据结构前端框架开发语言
    前言在上篇文章中我们了解了响应式原理，并在最后实现了reactive。上文链接Vue3响应式原理实现与track和trigger依赖收集和触发依赖在我们的日常业务中，我们有可能需要将一个基础数据类型的值也转换成响应式的，而reactive只能代理对象，我们需要对基础数据类型的值也进行读写操作的拦截，但Proxy无法实现对基础数据类型值读写操作的拦截。所以Vue设计了Ref,以及相关api本篇文章实
  • 手撸vue3核心源码——响应式原理(isRef和unRef) 前端不是渣男 前端vue.js
    今天来实现一下ref的功能函数，isRef与unRefisRefisRef和isReactive一样，都是用于检测数据类型，isRef是检测是不是一个ref对象,跟isReactive函数实现起来一样,我们先来写一个单元测试这里要实现的功能是，检测ref对象肯定就通过返回true，检测普通类型数据以及reactive对象都是falseit("itshouldreturnaboolean",()=>
  • 基于springboot+vue的“考研资讯平台”程序设计实现【毕业论文，源码】 一枚务实的码农 毕业设计毕设考研springboot毕业论文系统源码
    摘要随着现在网络的快速发展，网络的应用在各行各业当中它很快融入到了许多学校的眼球之中，他们利用网络来做这个电商的服务，随之就产生了“考研资讯平台”，这样就让学生考研资讯平台更加方便简单。对于本考研资讯平台的设计来说，它主要是采用java技术。在整个系统的设计当中它是应用mysql数据库来完成的，具体根据网上考研资讯平台的现状来进行开发的，具体根据学生需求实现网上考研资讯平台网络化的管理，各类信息有
  • QMQTT在项目中的用法 好学松鼠 c++qt
    在一次项目实践中，需要使用MQTT协议向服务器发送数据，经过了解之后MQTT协议底层是基于TCP协议的。正好使用QT在开发项目，就在网上搜索了MQTT相关的开源三方库，因此就找到了基于QT的QMQTT的库。QMQTT库的源码可以再github或者gitee上获取到，具体的用法如下：1、初始化QMQTT#include"qmqtt.h"//服务器IP端口QMQTT::Client*client=ne
  • 如果面试官问你CAS，你还这么答，可能就要回去等通知了 爱玛士 程序员面试Javajava面试开发语言程序员架构
    前言大家好，我是JAVA高级开发之路，一个总在为粉丝解决面试题的程序员。最近有几个粉丝说在面试面试中遇到了CAS的问题，连着几次面试都没有让面试官满意，区区CAS底层源码，怎能难倒咱们这届程序员们呢？都支棱起来，跟我一起来搞定CAS底层源码。什么是CASCAS的全称是Compare-And-Swap，它是CPU并发原语。它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原
  • Jetpack LiveData源码分析 xiangxiongfly915 #AndroidJetpack系列JetpackLiveData源码分析
    文章目录JetpackLiveData源码分析前提源码分析注册订阅流程LiveData#observe()LifecycleRegistry#addObserver()ObserverWithState#dispatchEvent()LiveData#removeObserver()LiveData$LifecycleBoundObserver类LifecycleBoundObserver#sho
  • Protobuf学习 - 入门 weixin_30892987 c/c++python数据结构与算法
    古之立大事者，不惟有超世之才，亦必有坚忍不拔之志--苏轼·《晁错论》从公司的项目源码中看到了这个东西，觉得挺好用的，写篇博客做下小总结。下面的操作以C++为编程语言，protoc的版本为libprotoc3.2.0。一、Protobuf？1.是什么？GoogleProtocolBuffer(简称Protobuf)是一种轻便高效的结构化数据存储格式，平台无关、语言无关、可扩展，可用于通讯协议和数据存
  • 使用pyinstaller配合nuitka打包，发布python程序 孟德尔单杀豌豆射手 python
    引言软件版本：pyinstaller6.3.0,nuitka2.0.3,win7及win11均已测试通过。使用本文打包方法打包完成后使用pyinstxtractor.py解包，源码均已加密。众所周知，python程序目前有两种常用的打包方式，pyinstaller及nuitka，根据我的经验总结，各自的优缺点如下：pyinstaller：打包速度很快，成功率很高，但是运行速度比nuitka打包的程
  • 基于nodejs+vue的美妆彩妆网站的设计与实现(源码+LW+调试文档+讲解等) 程序员gelei nodejs毕业设计项目vue.js前端javascript
    目录：博主介绍：完整视频演示：系统技术介绍：后端Java介绍前端框架Vue介绍具体功能截图：部分代码参考：Mysql表设计参考：项目测试：项目论文：为什么选择我：源码获取：博主介绍：博主：程序员gelei：全网拥有20W+粉丝、CSDN作者、博客专家、全栈领域优质创作者、平台优质Java创作者、专注于Java、小程序、python、安卓技术领域和毕业项目实战✌Java精品实战案例《1000套》20
  • ExoPlayer架构详解与源码分析（17）——TrackSelector 山雨楼 ExoPlayer架构android音视频ExoPlayerMedia3源码
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
  • ExoPlayer架构详解与源码分析（12）——Cache 山雨楼 ExoPlayer架构android音视频ExoPlayerMedia3源码
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
  • ExoPlayer架构详解与源码分析（7）——SampleQueue(4) 2401_83740189 程序员架构
    long[]newSourceIds=newlong[newCapacity];long[]newOffsets=newlong[newCapacity];long[]newTimesUs=newlong[newCapacity];int[]newFlags=newint[newCapacity];int[]newSizes=newint[newCapacity];CryptoData[]newC
  • 基于django+vue代驾管理系统【开题报告+程序+论文】-计算机毕设 zhjie102 djangovue.js课程设计
    本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表开题报告内容研究背景随着城市化进程的加速和人们生活水平的提高，私家车数量急剧增加，但随之而来的酒驾问题也日益严峻，严重威胁着道路交通安全与公众生命财产安全。为了有效遏制酒驾行为，代驾服务应运而生并迅速普及。然而，当前市场上的代驾服务大多依赖于电话预约、人工调度等传统方式，存在效率低下
  • idea自动下载gradle_解决 IDEA 导入 Gradle 项目默认下载 Gradle.zip 失败 weixin_39730671 idea自动下载gradle
    这几天打算看看Spring-Framework的源码，于是将Spring-Framework的源码从GitHub拉到了Gitee，然后从Gitee上面下载到本地，几经波折终于下载到本地了。欣喜若狂的打开IDEA，Open了这个刚下载好的源码项目，结果一打开项目，它便自己开始下载起了gradle-6.5.1-bin.zip，下载了老半天都没啥动静，最后还直接给超时失败了。本来以前也不这样啊，我记得之
  • CTF——web总结 oliveira-time ctfweb安全
    解题思路做题先看源码关注可下载的资源(zip压缩包)抓包寻找可能存在的加密信息（base64）不管三七二十一先扫描目录再说ps：正常的应该是先扫描目录，然后发现后台进行爆破，发现爆破困难，然后去社工找其他信息。CTF——web个人总结_ctfweb-CSDN博客
  • fetch-event-source 如何通过script全局引入 cuiyuchen111 javascript前端
    fetchEventSource源码中导出了两种类型的包cjs和esm。但是有个需求如何在原生是js中通过script标签引呢？需要加上type=module。今天介绍另一种方法下载源码文件：https://github.com/Azure/fetch-event-source.git安装:npminstall--save-devwebpackwebpack-clits-loadertypescr
  • 开源项目低代码表单FormCreate从Vue2到Vue3升级指南 低代码研究员 FormCreate开源低代码FormCreate低代码表单低代码设计器动态表单
    开源项目低代码表单FormCreatev3版本基于Vue3.0构建，尽管功能与v2版本大致相同，但有一些重要的变更和不兼容项需要注意。源码地址:Github|GiteeFormCreatev3对比v2版本在一些功能和配置项上做了调整，以更好地支持Vue3的新特性。以下是v2到v3升级过程中需要关注的变化和调整。移除配置项在v3版本中，以下配置项已被移除，因为它们在Vue3中不再适用：attrs：在
  • 一文搞懂 Flink Task 数据交互之数据写源码 mn_kw flink交互java
    一文搞懂FlinkTask数据交互之数据写源码1.RecordWriterOutput2.RecordWriter3.数据分区器ChannelSelector4.数据输出模型ResultPartition5.子模型ResultSubpartition6.本地buffer池LocalBufferPool7.获取buffer8.将buffer添加到ResultSubpartitionFlink重要源码
  • source insight4.0中文乱码解决方法 鹿屿二向箔 c语言stm32keilmdk
    Sourceinsight是强大、顺手的代码编辑器，它几乎支持所有的语言，包括：C，C++，C#，HTML等等，能够自动创建并维护它自己高性能的符号数据库，包括函数、全局变量、结构、类和工程源文件里定义的其它类型的符号，对于大工程的源码阅读非常方便。但是因为是国外软件，对中文支持不是很好，很多电脑安装使用都会出现注释乱码问题，很让人抓狂。网上很多人遇到类似的问题，也有很多解决方式，也有很多“终极解
  • 二分查找排序算法 周凡杨 java二分查找排序算法折半
    一：概念 二分查找又称 折半查找（ 折半搜索/ 二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而 查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表 分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
  • java中的BigDecimal bijian1013 javaBigDecimal
            在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。         原文地址：http://blog.csdn.net/ugg/article/de
  • Shell echo命令详解 daizj echoshell
    Shell echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： echo string 您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: echo "It is a test" 这里的双引号完全可以省略，以下命令与上面实例效果一致： echo Itis a test 2.显示转义
  • Oracle DBA 简单操作 周凡杨 oracle dba sql
    --执行次数多的SQL select sql_text,executions from (      select sql_text,executions from v$sqlarea order by executions desc      ) where rownum<81;  &nb
  • 画图重绘 朱辉辉33 游戏
      我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。   在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
  • 线程之初体验 西蜀石兰 线程
    一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。 之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。 线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。 你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
  • linux集群互相免登陆配置 林鹤霄 linux
    配置ssh免登陆 1、生成秘钥和公钥    ssh-keygen -t rsa 2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub    其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密    c
  • mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql
    原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html   原因是你使用的InnoDB   表类型的时候, 默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 因为有的锁等待超过了这个时间,所以抱错.   你可以把这个时间加长,或者优化存储
  • Socket编程 基本的聊天实现。 alleni123 socket
    public class Server { //用来存储所有连接上来的客户 private List<ServerThread> clients; public static void main(String[] args) { Server s = new Server(); s.startServer(9988); } publi
  • 多线程监听器事件模式(一个简单的例子) 百合不是茶 线程监听模式
        多线程的事件监听器模式   监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到        创建多线程的事件监听器模式 思路:    1, 创建线程并启动,在创建线程的位置设置一个标记     2,创建队
  • spring InitializingBean接口 bijian1013 javaspring
    spring的事务的TransactionTemplate，其源码如下： public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{ ... } TransactionTemplate继承了DefaultT
  • Oracle中询表的权限被授予给了哪些用户 bijian1013 oracle数据库权限
            Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 select t.table_name as "表名", t.grantee as "被授权的属组", t.owner as "对象所在的属组"
  • 【Struts2五】Struts2 参数传值 bit1129 struts2
    Struts2中参数传值的3种情况 1.请求参数绑定到Action的实例字段上 2.Action将值传递到转发的视图上 3.Action将值传递到重定向的视图上   一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上 Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
  • 【Kafka十四】关于auto.offset.reset[Q/A] bit1129 kafka
    I got serveral questions about  auto.offset.reset. This configuration parameter governs how  consumer read the message from  Kafka when  there is no initial offset in ZooKeeper or
  • nginx gzip压缩配置 ronin47 nginx gzip 压缩范例
    nginx gzip压缩配置 更多 0 nginx gzip 配置   随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
  • java-13.输入一个单向链表，输出该链表中倒数第 k 个节点 bylijinnan java
    two cursors. Make the first cursor go K steps first. /* * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点 */ public void displayKthItemsBackWard(ListNode head,int k){ ListNode p1=head,p2=head;
  • Spring源码学习-JdbcTemplate queryForObject bylijinnan javaspring
    JdbcTemplate中有两个可能会混淆的queryForObject方法： 1. Object queryForObject(String sql, Object[] args, Class requiredType) 2. Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 第1个方法是只查
  • [冰川时代]在冰川时代,我们需要什么样的技术? comsci 技术
         看美国那边的气候情况....我有个感觉...是不是要进入小冰期了?      那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段...   &nb
  • js 获取浏览器型号 cuityang js浏览器
    根据浏览器获取iphone和apk的下载地址 <!DOCTYPE html> <html> <head>     <meta charset="utf-8" content="text/html"/>     <meta name=
  • C# socks5详解 转 dalan_123 socketC#
    http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html  这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
  • 运维 Centos问题汇总 dcj3sjt126com 云主机
    一、sh 脚本不执行的原因 sh脚本不执行的原因 只有2个 1.权限不够 2.sh脚本里路径没写完整。   二、解决You have new mail in /var/spool/mail/root 修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 MailTo = MailFrom   三、查询连接数
  • Yii防注入攻击笔记 dcj3sjt126com sqlWEB安全yii
    网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号 这里有个转义对照表： http://blog.csdn.net/xinzhu1990/articl
  • MongoDB简介[一] eksliang mongodbMongoDB简介
    MongoDB简介 转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用        MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。        另外，不
  • zookeeper windows 入门安装和测试 greemranqq zookeeper安装分布式
    一、序言       以下是我对zookeeper 的一些理解：      zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。       栗子1号：       假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
  • Spring之使用事务缘由(2-注解实现) ihuning spring
      Spring事务注解实现   1. 依赖包：     1.1 spring包：           spring-beans-4.0.0.RELEASE.jar           spring-context-4.0.0.
  • iOS App Launch Option 啸笑天 option
    iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。   launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节 。 1、若用户直接
  • jdk与jre的区别（_） macroli javajvmjdk
    简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。  JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。 如果安装了JDK，会发同你
  • Updates were rejected because the tip of your current branch is behind qiaolevip 学习永无止境每天进步一点点众观千象git
    $ git push joe prod-2295-1 To [email protected]:joe.le/dr-frontend.git ! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward) error: failed to push some refs to '[email protected]
  • [一起学Hive]之十四-Hive的元数据表结构详解 superlxw1234 hivehive元数据结构
    关键字：Hive元数据、Hive元数据表结构   之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。 本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。   文章最后面，会以一个示例来全面了解一下，
  • Spring 3.2.14，4.1.7，4.2.RC2发布 wiselyman Spring 3
      Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。   其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。   其中Spring 4.1.7主要包含这些更新内容。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他