在JAVA中使用LUA脚本记,javaj调用lua脚本的函数（转）

1
2
3
4
5
6
7
8
9

// 创建一个Lua执行的全局环境。
LuaValue global = JsePlatform.debugGlobals();
 
// 获得loadstring变量，这个变量存储了一个方法，相当于JavaScript里的eval。
LuaValue loadstring = global.get("loadstring");
// 第一个call()方法是调用loadstring这个方法，其参数中使用了LueValue.valueOf()这个静态方法把Java的数据封装成Lua能够使用的数据，第二个call()方法是执行字符串中的表达式，结果是输出了“Hello world!”。
loadstring.call(LuaValue.valueOf("print('Hello world!')")).call();
// 与之类似的还有loadfile，不过它的作用是接受一个文件路径，读入这个文件的内容，执行时调用call。
global.get("loadfile").call("./test.lua").call();

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
98
99
100
101
102
103
104
105
106
107
108
109

package net.airtheva;
 
import java.io.File;
 
import org.luaj.vm2.LuaThread;
import org.luaj.vm2.LuaValue;
import org.luaj.vm2.lib.OneArgFunction;
import org.luaj.vm2.lib.ZeroArgFunction;
import org.luaj.vm2.lib.jse.JsePlatform;
 
public class LuaWorker {
 
  class _Worker implements Runnable {
 
    @Override
    public void run() {
     
      mIsStopping = false;
      mIsStopped = false;
     
      // 产生协同线程。
      mLuaThread = mCoroutineCreate.call(mLoadString.call(LuaValue.valueOf("while true do print('!') end")));
     
      // 执行协同线程（该线程将被阻塞）。
      mCoroutineResume.call(mLuaThread);
     
    }
   
  }
 
  Thread mThread;
 
  LuaValue mGlobal;
 
  LuaValue mLoadString;
 
  LuaValue mDebugSetHook;
 
  LuaValue mNativeCoroutineCreate;
  LuaValue mCoroutineCreate;
  LuaValue mCoroutineYield;
  LuaValue mCoroutineResume;
 
  LuaValue mLuaThread;
 
  boolean mIsStopping = true;
  boolean mIsStopped = true;
 
  public LuaWorker() {
   
    mGlobal = JsePlatform.debugGlobals();
   
    mLoadString = mGlobal.get("loadstring");
   
    mDebugSetHook = mGlobal.get("debug").get("sethook");
   
    LuaValue coroutine = mGlobal.get("coroutine");
    mNativeCoroutineCreate = coroutine.get("create");
    coroutine.set("create", new OneArgFunction() {
     
      @Override
      public LuaValue call(LuaValue value) {
        Debug.L("Called.");
        LuaThread thread = mNativeCoroutineCreate.call(value).checkthread();
        mDebugSetHook.invoke(new LuaValue[] {
            thread,
            new OneArgFunction() {
              @Override
              public LuaValue call(LuaValue value) {
                if(mIsStopping) {
                  //LuaThread.yield(LuaValue.NIL);
                  mCoroutineYield.call(); // 暂停本线程，上面那行也能起到一样的效果。
                  mIsStopped = true;
                }
                return LuaValue.NIL;
              }
            },
            LuaValue.valueOf("crl"), // 这里ComputerCraft用的是LuaValue.NIL，但我这边好像停不下来…
            LuaValue.valueOf(100000) // 这个100000是照着抄的，其实我不知道这是啥意思，等深入使用Lua了应该就会知道了。
        });
        return thread;
      }
     
    });
   
    mCoroutineCreate = coroutine.get("create");
    mCoroutineYield = coroutine.get("yield");
    mCoroutineResume = coroutine.get("resume");
   
  }
 
  public void Start() {
   
    mThread = new Thread(new _Worker());
    mThread.start();
   
  }
 
  public void Stop() {
   
    // 可能回收没做好。
   
    mIsStopping = true;
    mThread.interrupt();
    mThread = null;
   
  }
 
}