业务脚本：为什么说可编程订阅式缓存服务更有用？

package main


import "github.com/yuin/gopher-lua"


// VarChange 用于被lua调用的函数
func VarChange(L *lua.LState) int {
   lv := L.ToInt(1)            //获取调用函数的第一个参数，并且转成int
   L.Push(lua.LNumber(lv * 2)) //将参数内容直接x2，并返回结果给lua
return 1                    //返回结果参数个数
}


func main() {
   L := lua.NewState() //新lua线程
defer L.Close() //程序执行完毕自动回收


// 注册lua脚本可调用函数
// 在lua内调用varChange函数会调用这里注册的Go函数 VarChange
   L.SetGlobal("varChange", L.NewFunction(VarChange))


//直接加载lua脚本
//脚本内容为：
// print "hello world"
// print(varChange(20)) # lua中调用go声明的函数
if err := L.DoFile("hello.lua"); err != nil {
panic(err)
   }


// 或者直接执行string内容
if err := L.DoString(`print("hello")`); err != nil {
panic(err)
   }
}


// 执行后输出结果：
//hello world
//40
//hello
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.

package main


import (
"fmt"
"github.com/yuin/gopher-lua"
)


func main() {
   L := lua.NewState()
defer L.Close()
//加载脚本
   err := L.DoFile("vardouble.lua")
if err != nil {
panic(err)
   }
// 调用lua脚本内函数
   err = L.CallByParam(lua.P{
      Fn:      L.GetGlobal("varDouble"), //指定要调用的函数名
      NRet:    1,                        // 指定返回值数量
      Protect: true,                     // 错误返回error
   }, lua.LNumber(15)) //支持多个参数
if err != nil {
panic(err)
   }
//获取返回结果
   ret := L.Get(-1)
//清理下，等待下次用
   L.Pop(1)


//结果转下类型，方便输出
   res, ok := ret.(lua.LNumber)
if !ok {
panic("unexpected result")
   }
   fmt.Println(res.String())
}


// 输出结果：
// 30
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.

function varDouble(n)
return n * 2
end
1.
2.
3.

//保存lua的LState的池子
type lStatePool struct {
    m     sync.Mutex
    saved []*lua.LState
}
// 获取一个LState
func (pl *lStatePool) Get() *lua.LState {
    pl.m.Lock()
defer pl.m.Unlock()
    n := len(pl.saved)
if n == 0 {
return pl.New()
    }
    x := pl.saved[n-1]
    pl.saved = pl.saved[0 : n-1]
return x
}


//新建一个LState
func (pl *lStatePool) New() *lua.LState {
    L := lua.NewState()
// setting the L up here.
// load scripts, set global variables, share channels, etc...
//在这里我们可以做一些初始化
return L
}


//把Lstate对象放回到池中，方便下次使用
func (pl *lStatePool) Put(L *lua.LState) {
    pl.m.Lock()
defer pl.m.Unlock()
    pl.saved = append(pl.saved, L)
}


//释放所有句柄
func (pl *lStatePool) Shutdown() {
for _, L := range pl.saved {
        L.Close()
    }
}
// Global LState pool
var luaPool = &lStatePool{
    saved: make([]*lua.LState, 0, 4),
}


//协程内运行的任务
func MyWorker() {
//通过pool获取一个LState
   L := luaPool.Get()
//任务执行完毕后，将LState放回pool
defer luaPool.Put(L)
// 这里可以用LState变量运行各种lua脚本任务
//例如 调用之前例子中的的varDouble函数
   err = L.CallByParam(lua.P{
      Fn:      L.GetGlobal("varDouble"), //指定要调用的函数名
      NRet:    1,                        // 指定返回值数量
      Protect: true,                     // 错误返回error
   }, lua.LNumber(15)) //这里支持多个参数
if err != nil {
panic(err) //仅供演示用，实际生产不推荐用panic
   }
}
func main() {
defer luaPool.Shutdown()
go MyWorker() // 启动一个协程
go MyWorker() // 启动另外一个协程
/* etc... */
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.

// go用于交换的 struct
type Person struct {
    Name string
}


//为这个类型定义个类型名称
const luaPersonTypeName = "person"


// 在LState对象中，声明这种类型，这个只会在初始化LState时执行一次
// Registers my person type to given L.
func registerPersonType(L *lua.LState) {
//在LState中声明这个类型
    mt := L.NewTypeMetatable(luaPersonTypeName)
//指定 person 对应 类型type 标识
//这样 person在lua内就像一个 类声明
    L.SetGlobal("person", mt)
// static attributes
// 在lua中定义person的静态方法
// 这句声明后 lua中调用person.new即可调用go的newPerson方法
    L.SetField(mt, "new", L.NewFunction(newPerson))
// person new后创建的实例，在lua中是table类型，你可以把table理解为lua内的对象
// 下面这句主要是给 table定义一组methods方法，可以在lua中调用
// personMethods是个map[string]LGFunction 
// 用来告诉lua，method和go函数的对应关系
    L.SetField(mt, "__index", L.SetFuncs(L.NewTable(), personMethods))
}
// person 实例对象的所有method
var personMethods = map[string]lua.LGFunction{
"name": personGetSetName,
}
// Constructor
// lua内调用person.new时，会触发这个go函数
func newPerson(L *lua.LState) int {
//初始化go struct 对象 并设置name为 1
    person := &Person{L.CheckString(1)}
// 创建一个lua userdata对象用于传递数据
// 一般 userdata包装的都是go的struct，table是lua自己的对象
    ud := L.NewUserData() 
    ud.Value = person //将 go struct 放入对象中
// 设置这个lua对象类型为 person type
    L.SetMetatable(ud, L.GetTypeMetatable(luaPersonTypeName))
// 将创建对象返回给lua
    L.Push(ud)
//告诉lua脚本，返回了数据个数
return 1
}
// Checks whether the first lua argument is a *LUserData 
// with *Person and returns this *Person.
func checkPerson(L *lua.LState) *Person {
//检测第一个参数是否为其他语言传递的userdata
    ud := L.CheckUserData(1)
// 检测是否转换成功
if v, ok := ud.Value.(*Person); ok {
return v
    }
    L.ArgError(1, "person expected")
return nil
}
// Getter and setter for the Person#Name
func personGetSetName(L *lua.LState) int {
// 检测第一个栈，如果就只有一个那么就只有修改值参数
    p := checkPerson(L)
if L.GetTop() == 2 {
//如果栈里面是两个，那么第二个是修改值参数
        p.Name = L.CheckString(2)
//代表什么数据不返回，只是修改数据
return 0
    }
//如果只有一个在栈，那么是获取name值操作，返回结果
    L.Push(lua.LString(p.Name))


//告诉会返回一个参数
return 1
}
func main() {
// 创建一个lua LState
    L := lua.NewState()
defer L.Close()


//初始化 注册
    registerPersonType(L)
// 执行lua脚本
if err := L.DoString(`
        //创建person，并设置他的名字
        p = person.new("Steven")
        print(p:name()) -- "Steven"
        //修改他的名字
        p:name("Nico")
        print(p:name()) -- "Nico"
    `); err != nil {
panic(err)
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.