2020-02-09
OpenResty学习指南(二)

不一样的元宵节

我的个人博客:https://www.luozhiyun.com/

数据结构table

table并没有区分开数组、哈希、集合等概念,而是揉在了一起。

local color = {first = "red", "blue", third = "green", "yellow"}
print(color["first"])                 --> output: red
print(color[1])                         --> output: blue
print(color["third"])                --> output: green
print(color[2])                         --> output: yellow
print(color[3])                         --> output: nil

table 库函数

获取元素个数

对于序列,用table.getn 或者一元操作符 # ,就可以正确返回元素的个数。

$ resty -e 'local t = { 1, 2, 3 }
print(table.getn(t)) ' # 返回3

不是序列的 table,就无法返回正确的值。

$ resty -e 'local t = { 1, a = 2 }
print(#t) ' #返回1

所以不要使用函数 table.getn 和一元操作符 # 。

我们可以使用 table.nkeys 来获取 table 长度,返回的是 table 的元素个数,包括数组和哈希部分的元素。

local nkeys = require "table.nkeys"
 
print(nkeys({}))  -- 0
print(nkeys({ "a", nil, "b" }))  -- 2
print(nkeys({ dog = 3, cat = 4, bird = nil }))  -- 2
print(nkeys({ "a", dog = 3, cat = 4 }))  -- 3

删除指定元素

第二个我们来看table.remove 函数,它的作用是在 table 中根据下标来删除元素,也就是说只能删除 table 中数组部分的元素

$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
  table.remove(color, 1)
  for k, v in pairs(color) do
      print(v)
  end'

这段代码会把下标为 1 的 blue 删除掉。

如果要删除哈希部分,把 key 对应的 value 设置为 nil 即可。

元素拼接函数

table.concat 以按照下标,把 table 中的元素拼接起来。只能拼接数组部分

$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
print(table.concat(color, ", "))'

使用table.concat函数后,它输出的是 blue, yellow,哈希的部分被跳过了。

插入一个元素

table.insert 函数,可以下标插入一个新的元素,自然,影响的还是 table 的数组部分。

$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
table.insert(color, 1,  "orange")
print(color[1])
'

color 的第一个元素变为了 orange。当然,你也可以不指定下标,这样就会默认插入队尾。

优化

预先生成数组

预先生成一个指定大小的数组,避免每次新增和删除数组元素的时候,都会涉及到数组的空间分配、resize 和 rehash。
如:

local new_tab = require "table.new"
 local t = new_tab(100, 0)
 for i = 1, 100 do
   t[i] = i
 end

循环使用单个 table

table.clear 函数它会把数组中的所有数据清空,但数组的大小不会变。
如下:

local local_plugins = {}
 
 
function load()
    core.table.clear(local_plugins)
 
 
    local local_conf = core.config.local_conf()
    local plugin_names = local_conf.plugins
 
 
    local processed = {}
    for _, name in ipairs(plugin_names) do
        if processed[name] == nil then
            processed[name] = true
            insert_tab(local_plugins, name)
        end
    end
 
 
    return local_plugins

local_plugins 这个数组,是 plugin 这个模块的 top level 变量。在 load 这个加载插件函数的开始位置, table 就会被清空,然后根据当前的情况生成新的插件列表。

table 池

lua-tablepool,可以用缓存池的方式来保存多个 table,以便随用随取。

local tablepool = require "tablepool"
 local tablepool_fetch = tablepool.fetch
 local tablepool_release = tablepool.release
 
 
local pool_name = "some_tag" 
local function do_sth()
     local t = tablepool_fetch(pool_name, 10, 0)
     -- -- using t for some purposes
    tablepool_release(pool_name, t) 
end

缓存

OpenResty 中有两个缓存的组件:shared dict 缓存和 lru 缓存。前者只能缓存字符串对象,缓存的数据有且只有一份,每一个 worker 都可以进行访问,所以常用于 worker 之间的数据通信。后者则可以缓存所有的 Lua 对象,但只能在单个 worker 进程内访问,有多少个 worker,就会有多少份缓存数据。

vuex源码简析

shared dict

$ resty --shdict='dogs 1m' -e 'local dict = ngx.shared.dogs
                               dict:set("Tom", 56)
                               print(dict:get("Tom"))'

需要事先在 Nginx 的配置文件中,声明一个内存区 dogs,然后在 Lua 代码中才可以使用。

共享字典中还有一个 get_stale 的读取数据的方法,相比 get 方法,多了一个过期数据的返回值:

resty --shdict='dogs 1m' -e 'local dict = ngx.shared.dogs
                            dict:set("Tom", 56, 0.01)
                            ngx.sleep(0.02)
                             local val, flags, stale = dict:get_stale("Tom")
                            print(val)'

在上面的这个示例中,数据只在共享字典中缓存了 0.01 秒,在 set 后的 0.02 秒后,数据就已经超时了。这时候,通过 get 接口就不会获取到数据了,但通过 get_stale 还可能获取到过期的数据。

因为,在 shared dict 中存放的是缓存数据,即使缓存数据过期了,也并不意味着源数据就一定有更新。

lru 缓存

lru 缓存的接口只有 5 个:new、set、get、delete 和 flush_all。

如何使用:

resty -e 'local lrucache = require "resty.lrucache"
local cache, err = lrucache.new(200)
cache:set("dog", 32, 0.01)
ngx.sleep(0.02)
local data, stale_data = cache:get("dog")
print(stale_data)'

可以看到,在 lru 缓存中, get 接口的第二个返回值直接就是 stale_data,而不是像 shared dict 那样分为了 get 和 get_stale 两个不同的 API。

lua-resty-mlcache

lua-resty-mlcache用 shared dict 和 lua-resty-lrucache ,实现了多层缓存机制。

初始化:

local mlcache = require "resty.mlcache"
 
local cache, err = mlcache.new("cache_name", "cache_dict", {
    lru_size = 500,    -- size of the L1 (Lua VM) cache
    ttl = 3600,   -- 1h ttl for hits
    neg_ttl  = 30,     -- 30s ttl for misses
})
if not cache then
    error("failed to create mlcache: " .. err)
end

这段代码的开头引入了 mlcache 库,并设置了初始化的参数。第一个参数是缓冲名,第二个参数是字典名,第三个参数是个字典,里面是12个选填参数。

使用:

local function fetch_user(id)
    return db:query_user(id)
end
 
local id = 123
local user , err = cache:get(id , nil , fetch_user , id)
if err then
    ngx.log(ngx.ERR , "failed to fetch user: ", err)
    return
end
 
if user then
    print(user.id) -- 123
end

下面再看看这个库的架构与实现:

L1 缓存就是 lua-resty-lrucache。每一个 worker 中都有自己独立的一份,有 N 个 worker,就会有 N 份数据,自然也就存在数据冗余。

L2 缓存是 shared dict。所有的 worker 共用一份缓存数据,在 L1 缓存没有命中的情况下,就会来查询 L2 缓存。

L3 则是在 L2 缓存也没有命中的情况下,需要执行回调函数去外部数据库等数据源查询后,再缓存到 L2 中。

整体而言,从请求的角度来看:

  1. 首先会去查询 worker 内的 L1 缓存,如果 L1 命中就直接返回。
  2. 如果 L1 没有命中或者缓存失效,就会去查询 worker 间的 L2 缓存。如果 L2 命中就返回,并把结果缓存到 L1 中。
  3. 如果 L2 也没有命中或者缓存失效,就会调用回调函数,从数据源中查到数据,并写入到 L2 缓存中,这也就是 L3 数据层的功能。

需要做数据序列化的情况:

local mlcache = require "resty.mlcache"
 
local cache, err = mlcache.new("my_mlcache", "cache_shm", {
l1_serializer = function(i)
    return i   2
end,
})
 
local function callback()
    return 123456
end
 
local data = assert(cache:get("number", nil, callback))
assert(data == 123458)

在 new 中,我们设置的 l1_serializer 函数会在设置 L1 缓存前,把传入的数字加 2,也就是变成 123458。

使用GoldenGate完成MySQL到MySQL的同步


更多内容请关注十大外围足彩网站