java - LuaJ 数组/列表类型安全

Question

所以使用 LuaJ。

如果我通过，从 Java 到 Lua，用户数据 List<T>与类型 T ，Luaj 仍然允许通过 :add 将任何类型的对象插入到该数组中功能。例如:

Java代码:

import java.util.ArrayList;
import org.luaj.vm2.Globals;
import org.luaj.vm2.lib.jse.CoerceJavaToLua;
import org.luaj.vm2.lib.jse.JsePlatform;
import org.luaj.vm2.LuaValue;

ArrayList<Integer>ExampleList=new ArrayList<>();
ExampleList.add(1);
LuaValue[] LuaParams=new LuaValue[] {
    CoerceJavaToLua.coerce(ExampleList)
};

Globals globals=JsePlatform.standardGlobals();
try { globals.get("TestFunc").invoke(LuaValue.varargsOf(LuaParams)); }
catch(Exception e) {}

路亚:

function TestFunc(arr)
    arr:add("str")
    arr:add(2);
end

ExampleList 的结果:

{
    new Integer(1),
    new String("str"), //This should not be allowed!
    new Integer(2)
}

自ExampleList 以来不应该允许该字符串是 List<Integer>

问题:有什么方法可以保持类型安全吗？

如果它有助于测试，这里是将 lua 脚本添加到 lua 内存中的代码(就在 try{} 之前):

globals.load(
    "function TestFunc(arr)\n"+
    "        arr:add(\"str\")\n"+
    "        arr:add(2);\n"+
    "end",
"ExampleScript").call();

Answer 1

经过研究，我发现不可能找出数组被声明为什么泛型类型。 Java 不将该信息存储在对象中。在运行时，它只使用数组声明的类型作为当前变量引用。

您所能做的就是查看其中的对象以确定它应该是什么，但这并非万无一失。

如果数组是在另一个对象中定义的，那么您可以查看父对象的字段以获取数组的组件/模板/通用类型。

ArrayList reflection

[编辑于 2016-07-06] 我知道的另一个建议方法是使用实​​际存储类类型的接口(interface)扩展所有列表类。尽管对于该项目而言，这实际上并不实用。经过思考，Java 不存储列表的泛型类类型是有道理的。

我最终使用的解决方案是使用以下内容(在 Object[] 之后)编辑 org.luaj.vm2.lib.jse.JavaMethod.invokeMethod(Object instance, Varargs args) a = convertArgs(args); 行:

//If this is adding/setting to a list, make sure the object type matches the list's 0th object type
java.util.List TheInstanceList;
if(
    instance instanceof java.util.List && //Object is a list
    java.util.Arrays.asList("add", "set").contains(method.getName()) && //Adding/setting to list
    (TheInstanceList=(java.util.List)instance).size()>0 && //List already has at least 1 item
    !a[a.length>1 ? 1 : 0].getClass().isInstance(TheInstanceList.get(0)) //New item does not match type of item #0
)
    return LuaValue.error(String.format(
            "list coercion error: %s is not instanceof %s",
            a[a.length>1 ? 1 : 0].getClass().getName(),
            TheInstanceList.get(0).getClass().getName()
    ));

虽然这可以通过遍历两个对象的扩展父类型列表(java.lang.Object 之前的所有内容)来扩展以说明匹配的父类，但类型安全性较低-比我们项目所需的要明智。

我在上面使用的解决方案专门用于在 LUA 脚本投入生产之前清除它们中的错误。

我们最终可能还需要进行 hack，其中某些类在比较时被视为其祖先或继承类之一。

[2016-07-08编辑] 我最终添加了具有声明类型的列表的能力，因此不需要类型猜测。

上面代码块的替换代码:

//If this is adding/setting to a list, make sure the object has the proper class type
if(
    instance instanceof java.util.List && //Object is a list
    java.util.Arrays.asList("add", "set").contains(method.getName()) //Adding/setting to list
) {
    //If this is a TypedList, use its stored class for the typecheck
    java.util.List TheInstanceList=(java.util.List)instance;
    Class ClassInstance=null;
    if(instance instanceof lua.TypedList)
        ClassInstance=((lua.TypedList)instance).GetListClass();
    //Otherwise, check for a 0th object to typecheck against
    else if(TheInstanceList.size()>0) //List already has at least 1 item
        ClassInstance=TheInstanceList.get(0).getClass(); //Class of the 0th item

    //Check if new item does not match found class type
    if(
        ClassInstance!=null && //Only check if there is a class to check against
        !ClassInstance.isInstance(a[a.length>1 ? 1 : 0]) //Check the last parameter's class
    )
        return LuaValue.error(String.format(
                "list coercion error: %s is not instanceof %s",
                a[a.length>1 ? 1 : 0].getClass().getName(),
                ClassInstance.getName()
        ));
}

以及 TypedList 的代码:

/**
 * This is a special List class used with LUA which tells LUA what the types of objects in its list must be instances of.
 * Otherwise, when updating a list in LUA, whatever is the first object in a list is what all other objects must be an instance of.
 */
public interface TypedList {
    Class GetListClass();
}

作为 TypeList 的裸 ArrayList:

import java.util.ArrayList;

public class TypedArrayList<E> extends ArrayList<E> implements TypedList {
    private Class ListType;
    public TypedArrayList(Class c) {
        DefaultConstructor(c);
    };
    public TypedArrayList(Class c, java.util.Collection<? extends E> collection) {
        super(collection);
        DefaultConstructor(c);
    }
    private void DefaultConstructor(Class c) { ListType=c; }
    @Override public Class GetListClass() {
        return ListType;
    }
}