原理介绍

第一步 lua调用java方法，会用到luaj，看源码

local luaj = {
    }
local callJavaStaticMethod = LuaJavaBridge.callStaticMethod
local function checkArguments(args, sig)
    if type(args) ~= "table" then args = {
    } end
    if sig then return args, sig end

    sig = {
    "("}
    for i, v in ipairs(args) do
        local t = type(v)
        if t == "number" then
            sig[#sig + 1] = "F"
        elseif t == "boolean" then
            sig[#sig + 1] = "Z"
        elseif t == "function" then
            sig[#sig + 1] = "I"
        else
            sig[#sig + 1] = "Ljava/lang/String;"
        end
    end
    sig[#sig + 1] = ")V"

    return args, table.concat(sig)
end

function luaj.callStaticMethod(className, methodName, args, sig)
    local args, sig = checkArguments(args, sig)
    --echoInfo("luaj.callStaticMethod(\"%s\",\n\t\"%s\",\n\targs,\n\t\"%s\"", className, methodName, sig)
    return callJavaStaticMethod(className, methodName, args, sig)
end

return luaj

在这份源码中看到了LuaJavaBridge.callStaticMethod，这个是一个全局变量，下面看一下它的实现
LuaJavaBridge他是一个c++的类被注册到了lua的全局表中**

void LuaJavaBridge::luaopen_luaj(lua_State *L)
{
    
	s_luaState = L;
    lua_newtable(L);//生成一个table t放在栈顶L->top-1
    lua_pushstring(L, "callStaticMethod");//压入一个字符串funcName放在栈顶L->top-1
    lua_pushcfunction(L, LuaJavaBridge::callJavaStaticMethod);//压入一个c函数func放在栈顶L->top-1
    lua_rawset(L, -3);//设置t[funcName] = func,出栈两个元素，table t放在栈顶L->top-1
    lua_setglobal(L, "LuaJavaBridge");//设置全局变量G["LuaJavaBridge"] = t;
}

下面其实就进入到了C++调用java

/*
args:
    const char *className
    const char *methodName
    LUA_TABLE   args
    const char *sig
*/
int LuaJavaBridge::callJavaStaticMethod(lua_State *L)
{
    
    if (!lua_isstring(L, -4) || !lua_isstring(L, -3)  || !lua_istable(L, -2) || !lua_isstring(L, -1))
    {
    
    	lua_pushboolean(L, 0);
    	lua_pushinteger(L, LUAJ_ERR_INVALID_SIGNATURES);
    	return 2;
    }

    LOGD("%s", "LuaJavaBridge::callJavaStaticMethod(lua_State *L)");

    const char *className  = lua_tostring(L, -4);
    const char *methodName = lua_tostring(L, -3);
    const char *methodSig  = lua_tostring(L, -1);

    CallInfo call(className, methodName, methodSig);

    // check args
    lua_pop(L, 1);													/* L: args */
    int count = fetchArrayElements(L, -1);                      	/* L: args e1 e2 e3 e4 ... */
    jvalue *args = NULL;
    if (count > 0)
    {
    
	    args = new jvalue[count];
	    for (int i = 0; i < count; ++i)
	    {
    
	        int index = -count + i;
	        switch (call.argumentTypeAtIndex(i))
	        {
    
	            case TypeInteger:
	            	if (lua_isfunction(L, index))
	            	{
    
	                    args[i].i = retainLuaFunction(L, index, NULL);
	            	}
	            	else
	            	{
    
	            		args[i].i = (int)lua_tonumber(L, index);
	            	}
	                break;

	            case TypeFloat:
	                args[i].f = lua_tonumber(L, index);
	                break;

	            case TypeBoolean:
	                args[i].z = lua_toboolean(L, index) != 0 ? JNI_TRUE : JNI_FALSE;
	                break;

	            case TypeString:
	            default:
	                args[i].l = call.getEnv()->NewStringUTF(lua_tostring(L, index));
	                break;
	        }
	    }
	    lua_pop(L, count);                               			/* L: args */
    }

    bool success = args ? call.executeWithArgs(args) : call.execute();
    if (args) delete []args;

    if (!success)
    {
    
    	LOGD("LuaJavaBridge::callJavaStaticMethod(\"%s\", \"%s\", args, \"%s\") EXECUTE FAILURE, ERROR CODE: %d",
    			className, methodName, methodSig, call.getErrorCode());

    	lua_pushboolean(L, 0);
    	lua_pushinteger(L, call.getErrorCode());
    	return 2;
    }

	LOGD("LuaJavaBridge::callJavaStaticMethod(\"%s\", \"%s\", args, \"%s\") SUCCESS",
			className, methodName, methodSig);

	lua_pushboolean(L, 1);
	return 1 + call.pushReturnValue(L);
}

第二步在java中调用lua
需要在java中声明函数

package org.cocos2dx.lib;
public class Cocos2dxLuaJavaBridge
{
    
    public static native int callLuaFunctionWithString(int luaFunctionId, String value);
    public static native int callLuaGlobalFunctionWithString(String luaFunctionName, String value);
    public static native int retainLuaFunction(int luaFunctionId);
    public static native int releaseLuaFunction(int luaFunctionId);
}

在C++中实现这些函数

#include "Java_org_cocos2dx_lib_Cocos2dxLuaJavaBridge.h"
#include <android/log.h>
#include "CCLuaJavaBridge.h"
#include "base/ccUTF8.h"

#define  LOG_TAG    "Cocos2dxLuaJavaBridge_java"
#define  LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG,__VA_ARGS__)

extern "C" {
    

JNIEXPORT jint JNICALL Java_org_cocos2dx_lib_Cocos2dxLuaJavaBridge_callLuaFunctionWithString
  (JNIEnv *env, jclass cls, jint functionId, jstring value)
{
    
    std::string strValue = cocos2d::StringUtils::getStringUTFCharsJNI(env, value);
    int ret = LuaJavaBridge::callLuaFunctionById(functionId, strValue.c_str());
    return ret;
}

JNIEXPORT jint JNICALL Java_org_cocos2dx_lib_Cocos2dxLuaJavaBridge_callLuaGlobalFunctionWithString
  (JNIEnv *env, jclass cls, jstring luaFunctionName, jstring value)
{
    
    std::string functionNameStr = cocos2d::StringUtils::getStringUTFCharsJNI(env, luaFunctionName);
    std::string valueStr = cocos2d::StringUtils::getStringUTFCharsJNI(env, value);
    
    int ret = LuaJavaBridge::callLuaGlobalFunction(functionNameStr.c_str(), valueStr.c_str());
    return ret;
}

JNIEXPORT jint JNICALL Java_org_cocos2dx_lib_Cocos2dxLuaJavaBridge_retainLuaFunction
  (JNIEnv *env, jclass cls, jint luaFunctionId)
{
    
    return LuaJavaBridge::retainLuaFunctionById(luaFunctionId);
}

JNIEXPORT jint JNICALL Java_org_cocos2dx_lib_Cocos2dxLuaJavaBridge_releaseLuaFunction
  (JNIEnv *env, jclass cls, jint luaFunctionId)
{
    
    return LuaJavaBridge::releaseLuaFunctionById(luaFunctionId);
}

} // extern "C"

在看一下这个LuaJavaBridge::callLuaFunctionById(functionId, strValue.c_str())函数做了啥
前面说到LuaJavaBridge会被注册到lua的全局表中，嘿！没错，就在那个时候，这个对象偷偷记下了lua_State
这个lua_State在乱中就是灵魂的存在，有了它就可以操作lua了啊，下面的实现其实就是简单根据functionid去找lua的函数，找到以后就调用呗

int LuaJavaBridge::callLuaFunctionById(int functionId, const char *arg)
{
    
    lua_State *L = s_luaState;
    int top = lua_gettop(L);
                                                                /* L: */
    lua_pushstring(L, LUAJ_REGISTRY_FUNCTION);                  /* L: key */
    lua_rawget(L, LUA_REGISTRYINDEX);                           /* L: f_id */
    if (!lua_istable(L, -1))
    {
    
        lua_pop(L, 1);
        return -1;
    }

    lua_pushnil(L);                                             /* L: f_id nil */
    while (lua_next(L, -2) != 0)                                /* L: f_id f id */
    {
    
        int value = lua_tonumber(L, -1);
        lua_pop(L, 1);                                          /* L: f_id f */
        if (value == functionId)
        {
    
            lua_pushstring(L, arg);                             /* L: f_id f arg */
            int ok = lua_pcall(L, 1, 1, 0);                     /* L: f_id ret|err */
            int ret;
            if (ok == 0)
            {
    
                ret = lua_tonumber(L, -1);
            }
            else
            {
    
                ret = -ok;
            }

            lua_settop(L, top);
            return ret;
        }
    }                                                           /* L: f_id */

    lua_settop(L, top);
    return -1;
}

总结：
java和lua有相似之处，比如他们都是跑在虚拟机上，他们的虚拟机都是C写的
那么他们最终都是会编译成字节码，虚拟机在执行他们的时候，又会把他们通过语法分析和词法分析生成一条条机器指令
当lua程序运行起来的时候，可以把它理解为是lua虚拟机在执行机器指令，我们把c函数注册到lua的全局表中，当在lua中调用这个全局函数时，lua虚拟机就会去执行它的c函数
当java程序运行起来的时候，可以把它理解为是java虚拟机在执行指令，对于那些申明为native的java方法,它的实现在c++中，java虚拟机会把他编译为一条特殊的机器指令，当执行到这个指令的时候，就去调用c++函数了

我们用lua来调用java的方法,这个java方法是静态的，其实本质上还是用c来调用java,我们在lua中调用java的方法是c事先注册到lua中的全局变量c调用java,其实是获取java虚拟机，然后调用它的静态方法

我们用java来调用lua，其实是事先把lua函数注册到栈中的注册表里得到一个functionId，java会使用native方法来调用lua,这个方法，java虚拟机在执行它的时候，会去执行这个方法在其他语言的实现，这里的实现是在c语言端，所以c实现的这个方法并且带着functionId又去lua的栈中找之前注册函数lua的函数，找到以后再执行它

举个简单例子

lua端：
在一个可以被调用的地方，声明下面这个函数，比如按钮的回调

function MainScene:callJavaLogin()

    
    local callbackLua = function ( ... )
        print("与java端连接成功");
        self:readyLogin();
    end

    local className = "org/cocos2dx/lua/AppActivity"
    --java端对应的静态函数名
    local javaMethodName = "test"
    local args = {
     "hello android", callbackLua }
    local sigs = "(Ljava/lang/String;I)V" --传入string参数，无返回值  
    local luaj = require "cocos.cocos2d.luaj"
    local ok = luaj.callStaticMethod(className,javaMethodName,args,sigs)
    if not ok then
        print("call callback error")
    else
        print("call Back success")
    end
end

java端
在启动类AppActivity中实现下面这个静态方法

 //测试--------------------------
    public static void test(final String param,final int luaFunc) {
    
        System.out.println("----传过来的参数----param:"+param);
        System.out.println("-------luaFunc:"+luaFunc);
        
        /**
         * 给lua返回一个字符串
         */
        Cocos2dxLuaJavaBridge.callLuaFunctionWithString(luaFunc, "success");
        /**
         * 移除luaId
         */
        Cocos2dxLuaJavaBridge.releaseLuaFunction(luaFunc);
    }

打包即可观看结果

runOnGLThread与runOnUiThread

android的主线程指的就是UI线程，主要用来刷新界面和响应用户交互

在 cocos2d-x 启动后，Lua/C++代码将由 GL 线程调用，因此从 Lua/C++中调用的 Java 方法如果涉及到系统
用户界面的显示、更新操作，那么就必须让这部分代码切换到 UI 线程上去运行。
反之亦然，从 Java 调用 Lua/C++代码时，需要让这个调用在 GL 线程上执行，否则 Lua/C++代码虽然执行了，
但会无法更新 cocos2d-x 内部状态。
   确保 Lua/C++function 跑在 GL 线程（子线程），Java 代码跑在 UI 线程（主线程）

比如说支付，我们在游戏界面点击支付按钮，就是lua去调用java，那最后生成的支付界面一定要跑在UI线程里，同理如果我们想从java这边去调用某个游戏界面，那就需要在GL线程里操作，
如果在android端有一个非常耗时的操作，才可以刷新界面，可以将这个耗时的操作写在线程里，然后将结果调用runOnUiThread来刷新界面UI

感悟

我们用lua语言写的代码，最后都要变成字节码，而在生成字节码的同时，操作码指令也都生成完毕，最后在虚拟机的大循环中去执行这些指令，lua的声明语句也好，lua的赋值语句也好，还是lua的函数等，其实这些都没有真正的执行，他们都会变成一条条相互关联的操作码指令，这些执行的操作码指令的偏移地址都是1，在我们注册到lua虚拟机的c或者c++函数的实现中，可以看到栈的操作，这就是操作码指令偏移地址为1造成的，我们写的lua语句所生成的操作码指令，其实就是一个入栈的过程，到最后执行c函数，就可以模仿栈的操作了，比如函数的调用，假设我们调用一个输出函数print,然后给这个函数传几个想要打印的字符串，形如print(a,b,c,d)
第一步：操作码指令：getglobal 全局函数（print）---------》0x00000001
第二步：操作码指令：loadk 加载字符串 a----------------》0x00000002
第三步：操作码指令：loadk 加载字符串 b----------------》0x00000003
第四步：操作码指令：loadk 加载字符串 c----------------》0x00000004
第五步：操作码指令：loadk 加载字符串 d----------------》0x00000005
第六步：操作码指令：callfunc 执行函数---------------------》 0x00000006
第七步：操作码指令：return 函数返回----------------------》 0x00000006
OK 可以进去print这个c函数中去看看，真的有栈的进出的操作，一句总结就是，我们写的lua语句，lua虚拟机根据这些语句为我们生成一条条偏移地址为1的操作码指令，这其实就符合了栈的操作，你可以理解其实我们写的代码就是入栈的操作，c函数在执行的时候就是读栈的操作，确切的说，是读寄存器的操作