Openresty（Lua+Nginx）实践

　简介：

　　OpenResty（也称为 ngx_openresty）是一个全功能的 Web 应用服务器。它打包了标准的 Nginx 核心，很多的常用的第三方模块，以及它们的大多数依赖项。

　　OpenResty 致力于将你的服务器端应用完全运行于 Nginx 服务器中，充分利用 Nginx 的事件模型来进行非阻塞 I/O 通信。不仅仅是和 HTTP 客户端间的网络通信是非阻塞的，与MySQL、PostgreSQL、Memcached 以及 Redis 等众多远方后端之间的网络通信也是非阻塞的。

　　　　　　　　　　　　————章亦春　　

Lua基础数据类型

Lua表达式

Lua控制结构

Lua函数

　　函数调用的时候可以传参，形参（a,b）与实参（x,y）在使用上需要注意，在使用函数时实参若大于形参则多余的参数为nli（空）

Local function test(a,b)
 
    local temp = a
            a = b
            b = temp
            print(a,b)
end
local x = "hello"
local y = 20
print(x, y)
swap(x, y)    --调用swap函数
print(x, y)   --调用swap函数后，x和y的值并没有交换
 
-->output
hello 20
20  hello
hello 20

Openrsty连接redis连接池封装（connect,port）+auth 使用

--这是大神们封装好的redis连接池，在配置中修改ip和端口即可 文件放到 Openresty/lualib/resty/redis_iresty.lua
 
local redis_c = require "resty.redis"
 
local ok, new_tab = pcall(require, "table.new")
if not ok or type(new_tab) ~= "function" then
    new_tab = function (narr, nrec) return {} end
end
 
local _M = new_tab(0, 155)
_M._VERSION = '0.01'
 
local commands = {
    "append",            "auth",              "bgrewriteaof",
    "bgsave",            "bitcount",          "bitop",
    "blpop",             "brpop",
    "brpoplpush",        "client",            "config",
    "dbsize",
    "debug",             "decr",              "decrby",
    "del",               "discard",           "dump",
    "echo",
    "eval",              "exec",              "exists",
    "expire",            "expireat",          "flushall",
    "flushdb",           "get",               "getbit",
    "getrange",          "getset",            "hdel",
    "hexists",           "hget",              "hgetall",
    "hincrby",           "hincrbyfloat",      "hkeys",
    "hlen",
    "hmget",              "hmset",      "hscan",
    "hset",
    "hsetnx",            "hvals",             "incr",
    "incrby",            "incrbyfloat",       "info",
    "keys",
    "lastsave",          "lindex",            "linsert",
    "llen",              "lpop",              "lpush",
    "lpushx",            "lrange",            "lrem",
    "lset",              "ltrim",             "mget",
    "migrate",
    "monitor",           "move",              "mset",
    "msetnx",            "multi",             "object",
    "persist",           "pexpire",           "pexpireat",
    "ping",              "psetex",            "psubscribe",
    "pttl",
    "publish",      --[[ "punsubscribe", ]]   "pubsub",
    "quit",
    "randomkey",         "rename",            "renamenx",
    "restore",
    "rpop",              "rpoplpush",         "rpush",
    "rpushx",            "sadd",              "save",
    "scan",              "scard",             "script",
    "sdiff",             "sdiffstore",
    "select",            "set",               "setbit",
    "setex",             "setnx",             "setrange",
    "shutdown",          "sinter",            "sinterstore",
    "sismember",         "slaveof",           "slowlog",
    "smembers",          "smove",             "sort",
    "spop",              "srandmember",       "srem",
    "sscan",
    "strlen",       --[[ "subscribe",  ]]     "sunion",
    "sunionstore",       "sync",              "time",
    "ttl",
    "type",         --[[ "unsubscribe", ]]    "unwatch",
    "watch",             "zadd",              "zcard",
    "zcount",            "zincrby",           "zinterstore",
    "zrange",            "zrangebyscore",     "zrank",
    "zrem",              "zremrangebyrank",   "zremrangebyscore",
    "zrevrange",         "zrevrangebyscore",  "zrevrank",
    "zscan",
    "zscore",            "zunionstore",       "evalsha"
}
 
local mt = { __index = _M }
 
local function is_redis_null( res )
    if type(res) == "table" then
        for k,v in pairs(res) do
            if v ~= ngx.null then
                return false
            end
        end
        return true
    elseif res == ngx.null then
        return true
    elseif res == nil then
        return true
    end
 
    return false
end
 
-- change connect address as you need
function _M.connect_mod( self, redis )
    redis:set_timeout(self.timeout)
    return redis:connect("1.1.1.1", 6379)
end
 
function _M.set_keepalive_mod( redis )
    -- put it into the connection pool of size 100, with 60 seconds max idle time
    return redis:set_keepalive(60000, 1000)
end
 
function _M.init_pipeline( self )
    self._reqs = {}
end
 
function _M.commit_pipeline( self )
    local reqs = self._reqs
 
    if nil == reqs or 0 == #reqs then
        return {}, "no pipeline"
    else
        self._reqs = nil
    end
 
    local redis, err = redis_c:new()
    if not redis then
        return nil, err
    end
 
    local ok, err = self:connect_mod(redis)
    if not ok then
        return {}, err
    end
 
    redis:init_pipeline()
    for _, vals in ipairs(reqs) do
        local fun = redis[vals[1]]
        table.remove(vals , 1)
 
        fun(redis, unpack(vals))
    end
 
    local results, err = redis:commit_pipeline()
    if not results or err then
        return {}, err
    end
 
    if is_redis_null(results) then
        results = {}
        ngx.log(ngx.WARN, "is null")
    end
    -- table.remove (results , 1)
 
    self.set_keepalive_mod(redis)
 
    for i,value in ipairs(results) do
        if is_redis_null(value) then
            results[i] = nil
        end
    end
 
    return results, err
end
 
function _M.subscribe( self, channel )
    local redis, err = redis_c:new()
    if not redis then
        return nil, err
    end
 
    local ok, err = self:connect_mod(redis)
    if not ok or err then
        return nil, err
    end
 
    local res, err = redis:subscribe(channel)
    if not res then
        return nil, err
    end
 
    res, err = redis:read_reply()
    if not res then
        return nil, err
    end
 
    redis:unsubscribe(channel)
    self.set_keepalive_mod(redis)
 
    return res, err
end
 
local function do_command(self, cmd, ... )
    if self._reqs then
        table.insert(self._reqs, {cmd, ...})
        return
    end
 
    local redis, err = redis_c:new()
    if not redis then
        return nil, err
    end
 
    local ok, err = self:connect_mod(redis)
    if not ok or err then
        return nil, err
    end
 
    local fun = redis[cmd]
    local result, err = fun(redis, ...)
    if not result or err then
        -- ngx.log(ngx.ERR, "pipeline result:", result, " err:", err)
        return nil, err
    end
 
    if is_redis_null(result) then
        result = nil
    end
 
    self.set_keepalive_mod(redis)
 
    return result, err
end
 
for i = 1, #commands do
    local cmd = commands[i]
    _M[cmd] =
            function (self, ...)
                return do_command(self, cmd, ...)
            end
end
 
function _M.new(self, opts)
    opts = opts or {}
    local timeout = (opts.timeout and opts.timeout * 1000) or 1000
    local db_index= opts.db_index or 0
 
    return setmetatable({
            timeout = timeout,
            db_index = db_index,
            _reqs = nil }, mt)
end
 
return _M

我的调用，生成uuid后存储到redis里　：

ngx.req.read_body()
local args= ngx.req.get_uri_args()
for k,v in pairs(args) do
    local mac = v
    ngx.say(mac)
end
 
function guid()
    local seed={'e','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}
    local tb={}
    for i=1,32 do
        table.insert(tb,seed[math.random(1,16)])
    end
    local sid=table.concat(tb)
    return string.format('%s-%s-%s-%s-%s',
        string.sub(sid,1,8),
        string.sub(sid,9,12),
        string.sub(sid,13,16),
        string.sub(sid,17,20),
        string.sub(sid,21,32)
    )
end
 
--print('execute_time='..tostring(os.clock()-start_time))
local redis = require "resty.redis_iresty"
local red = redis:new()
redis:auth("password")
 
local s=0
--local start_time=os.clock()
while s<50 do
    s=s+1
   local uuid = guid()
   local ok, err = redis:hset("lbs",uuid,"1")
    if not ok then
        ngx.say("failed to set dog: ", err)
        return
    end
    ngx.say(s,uuid)
end

　　

　

认为Openresty完全可以替代nginx