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，就會有多少份緩存數據。

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。