Lua 与 Java 集成概述

Lua 与 Java 的集成主要通过 LuaJava 库实现，它允许在 Java 程序中嵌入 Lua 脚本引擎，实现双向调用。

集成方式

1. 添加依赖

首先需要在项目中添加 LuaJava 依赖：

<dependency>
    <groupId>org.luaj</groupId>
    <artifactId>luaj-jse</artifactId>
    <version>3.0.1</version>
</dependency>

2. 基本集成示例

import org.luaj.vm2.*;
import org.luaj.vm2.lib.jse.*;

public class LuaIntegrationExample {
    public static void main(String[] args) {
        // 创建 Lua 执行环境
        Globals globals = JsePlatform.standardGlobals();
        
        // 执行简单的 Lua 脚本
        LuaValue chunk = globals.load("print('Hello from Lua!')");
        chunk.call();
        
        // 在 Java 中设置变量供 Lua 使用
        globals.set("javaVar", LuaValue.valueOf("Hello Lua"));
        
        // 执行使用 Java 变量的 Lua 脚本
        LuaValue chunk2 = globals.load("print(javaVar)");
        chunk2.call();
    }
}

Java 调用 Lua

1. 执行 Lua 脚本

import org.luaj.vm2.*;
import org.luaj.vm2.lib.jse.*;

public class JavaCallsLua {
    public static void main(String[] args) {
        // 初始化 Lua 环境
        Globals globals = JsePlatform.standardGlobals();
        
        // 方式1：执行字符串形式的 Lua 代码
        String luaCode = "return 10 + 20";
        LuaValue chunk = globals.load(luaCode);
        LuaValue result = chunk.call();
        System.out.println("Result: " + result.toint()); // 输出: 30
        
        // 方式2：执行更复杂的 Lua 脚本
        String complexLua = 
            "function calculate(a, b) " +
            "  return a * b + 10 " +
            "end " +
            "return calculate(5, 6)";
            
        LuaValue complexChunk = globals.load(complexLua);
        LuaValue complexResult = complexChunk.call();
        System.out.println("Complex result: " + complexResult.toint()); // 输出: 40
    }
}

2. 向 Lua 传递 Java 对象

import org.luaj.vm2.*;
import org.luaj.vm2.lib.jse.*;

public class JavaObjectToLua {
    public static class Person {
        private String name;
        private int age;
        
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        public String getName() { return name; }
        public int getAge() { return age; }
        public void setAge(int age) { this.age = age; }
        
        public String introduce() {
            return "Hi, I'm " + name + ", " + age + " years old.";
        }
    }
    
    public static void main(String[] args) {
        Globals globals = JsePlatform.standardGlobals();
        
        // 创建 Java 对象并传递给 Lua
        Person person = new Person("张三", 25);
        globals.set("person", CoerceJavaToLua.coerce(person));
        
        // 在 Lua 中使用 Java 对象
        String luaScript = 
            "print(person:name()) " +
            "print('Age: ' .. person:age()) " +
            "person:setAge(30) " +
            "print(person:introduce())";
            
        LuaValue chunk = globals.load(luaScript);
        chunk.call();
    }
}

Lua 调用 Java

1. 注册 Java 方法供 Lua 调用

import org.luaj.vm2.*;
import org.luaj.vm2.lib.*;
import org.luaj.vm2.lib.jse.*;

public class LuaCallsJava {
    
    // 自定义 Lua 函数
    public static class MathLib extends TwoArgFunction {
        @Override
        public LuaValue call(LuaValue arg1, LuaValue arg2) {
            double result = Math.pow(arg1.todouble(), arg2.todouble());
            return LuaValue.valueOf(result);
        }
    }
    
    public static void main(String[] args) {
        Globals globals = JsePlatform.standardGlobals();
        
        // 注册自定义函数
        globals.set("power", new MathLib());
        
        // 注册 Java 静态方法
        globals.set("currentTime", new ZeroArgFunction() {
            @Override
            public LuaValue call() {
                return LuaValue.valueOf(System.currentTimeMillis());
            }
        });
        
        // 执行调用 Java 方法的 Lua 脚本
        String luaScript = 
            "local result = power(2, 3) " +
            "print('2^3 = ' .. result) " +
            "print('Current time: ' .. currentTime())";
            
        LuaValue chunk = globals.load(luaScript);
        chunk.call();
    }
}

2. 完整的双向交互示例

import org.luaj.vm2.*;
import org.luaj.vm2.lib.jse.*;

public class BidirectionalIntegration {
    
    public static class Calculator {
        public int add(int a, int b) {
            return a + b;
        }
        
        public int multiply(int a, int b) {
            return a * b;
        }
        
        public double divide(double a, double b) {
            if (b != 0) {
                return a / b;
            }
            throw new IllegalArgumentException("Division by zero");
        }
    }
    
    public static void main(String[] args) {
        // 初始化 Lua 环境
        Globals globals = JsePlatform.standardGlobals();
        
        // 创建计算器实例并注册到 Lua
        Calculator calc = new Calculator();
        globals.set("calculator", CoerceJavaToLua.coerce(calc));
        
        // 注册 Java 工具方法
        globals.set("formatResult", new VarArgFunction() {
            @Override
            public Varargs invoke(Varargs args) {
                StringBuilder sb = new StringBuilder("计算结果: ");
                for (int i = 1; i <= args.narg(); i++) {
                    if (i > 1) sb.append(", ");
                    sb.append(args.arg(i).tojstring());
                }
                return LuaValue.valueOf(sb.toString());
            }
        });
        
        // 复杂的 Lua 脚本，展示双向交互
        String luaScript = 
            "print('开始计算...') " +
            "local sum = calculator:add(10, 20) " +
            "local product = calculator:multiply(5, 6) " +
            "local quotient = calculator:divide(100, 4) " +
            "print(formatResult(sum, product, quotient)) " +
            "return {sum = sum, product = product, quotient = quotient}";
        
        // 执行脚本并获取返回值
        LuaValue chunk = globals.load(luaScript);
        LuaValue result = chunk.call();
        
        // 处理 Lua 返回的表数据
        if (result.istable()) {
            LuaTable table = result.checktable();
            System.out.println("Sum: " + table.get("sum").toint());
            System.out.println("Product: " + table.get("product").toint());
            System.out.println("Quotient: " + table.get("quotient").todouble());
        }
    }
}

实际应用场景

1. 配置管理

public class ConfigManager {
    public static void main(String[] args) {
        Globals globals = JsePlatform.standardGlobals();
        
        // 使用 Lua 作为配置文件
        String configLua = 
            "config = { " +
            "  server = { " +
            "    host = 'localhost', " +
            "    port = 8080, " +
            "    timeout = 30 " +
            "  }, " +
            "  database = { " +
            "    url = 'jdbc:mysql://localhost:3306/mydb', " +
            "    username = 'user', " +
            "    password = 'pass' " +
            "  } " +
            "}";
        
        globals.load(configLua).call();
        
        // 读取配置
        LuaTable config = globals.get("config").checktable();
        LuaTable server = config.get("server").checktable();
        
        String host = server.get("host").tojstring();
        int port = server.get("port").toint();
        
        System.out.println("Server: " + host + ":" + port);
    }
}

2. 业务规则引擎

public class BusinessRuleEngine {
    
    public static class Order {
        private double amount;
        private String customerType;
        
        public Order(double amount, String customerType) {
            this.amount = amount;
            this.customerType = customerType;
        }
        
        // Getters...
        public double getAmount() { return amount; }
        public String getCustomerType() { return customerType; }
    }
    
    public static void main(String[] args) {
        Globals globals = JsePlatform.standardGlobals();
        
        // 定义折扣规则的 Lua 脚本
        String discountRules = 
            "function calculateDiscount(order) " +
            "  local amount = order:amount() " +
            "  local customerType = order:customerType() " +
            "  local discount = 0 " +
            "  " +
            "  if customerType == 'VIP' then " +
            "    if amount > 1000 then " +
            "      discount = amount * 0.2 " +
            "    else " +
            "      discount = amount * 0.1 " +
            "    end " +
            "  elseif customerType == 'Regular' then " +
            "    if amount > 500 then " +
            "      discount = amount * 0.05 " +
            "    end " +
            "  end " +
            "  " +
            "  return discount " +
            "end";
        
        globals.load(discountRules).call();
        
        // 测试订单
        Order vipOrder = new Order(1500, "VIP");
        globals.set("order", CoerceJavaToLua.coerce(vipOrder));
        
        LuaValue result = globals.get("calculateDiscount").call(
            CoerceJavaToLua.coerce(vipOrder)
        );
        
        System.out.println("VIP订单折扣: " + result.todouble());
    }
}

优势与注意事项

优势：

1. 灵活性：业务逻辑可以通过 Lua 脚本动态修改，无需重新编译 Java 代码
2. 性能：Lua 执行效率高，适合嵌入式使用
3. 轻量级：Lua 引擎占用资源少
4. 易学易用：Lua 语法简单，业务人员也能快速上手

注意事项：

1. 安全性：需要对执行的 Lua 脚本进行安全检查
2. 错误处理：需要妥善处理 Lua 脚本执行异常
3. 性能监控：复杂脚本可能影响系统性能
4. 版本兼容：注意 LuaJava 库的版本兼容性

通过这种方式，Java 应用可以获得脚本语言的灵活性，同时保持 Java 的性能和稳定性。