Lua配置文件解析 - 元素码农

发布时间: 2025-03-24 12:18

↑

# Lua配置文件解析

本文将介绍如何使用Lua解析和处理配置文件,包括常见格式的解析、数据验证以及最佳实践。

## 基础知识

### 1. 常见配置格式

```lua
-- INI格式示例
[database]
host = localhost
port = 3306
user = root
password = secret

-- JSON格式示例
{
    "database": {
        "host": "localhost",
        "port": 3306,
        "user": "root",
        "password": "secret"
    }
}

-- YAML格式示例
database:
  host: localhost
  port: 3306
  user: root
  password: secret
```

### 2. Lua配置文件

```lua
-- config.lua
return {
    database = {
        host = "localhost",
        port = 3306,
        user = "root",
        password = "secret"
    },
    cache = {
        enabled = true,
        ttl = 3600
    }
}
```

## 解析实现

### 1. INI解析器

```lua
-- INI解析器实现
local INIParser = {}

function INIParser.parse(content)
    local result = {}
    local current_section = result
    
    for line in content:gmatch("[^\n]+") do
        -- 去除空白
        line = line:match("^%s*(.-)%s*$")
        
        if line ~= "" and line:sub(1,1) ~= ";" then
            -- 解析节
            local section = line:match("^%[([^%]]+)%]$")
            if section then
                result[section] = {}
                current_section = result[section]
            else
                -- 解析键值对
                local key, value = line:match("^([^=]+)=(.*)$")
                if key then
                    key = key:match("^%s*(.-)%s*$")
                    value = value:match("^%s*(.-)%s*$")
                    current_section[key] = value
                end
            end
        end
    end
    
    return result
end

-- 使用示例
local ini_content = [[
[database]
host = localhost
port = 3306

[cache]
enabled = true
ttl = 3600
]]

local config = INIParser.parse(ini_content)
print(config.database.host)  -- 输出: localhost
```

### 2. JSON解析

```lua
-- 使用cjson库
local json = require("cjson")

local function parse_json_file(filename)
    local file = io.open(filename, "r")
    if not file then
        error("Cannot open file: " .. filename)
    end
    
    local content = file:read("*all")
    file:close()
    
    local success, result = pcall(json.decode, content)
    if not success then
        error("Invalid JSON: " .. result)
    end
    
    return result
end

-- 使用示例
local config = parse_json_file("config.json")
print(config.database.host)
```

### 3. YAML解析

```lua
-- 使用lyaml库
local yaml = require("lyaml")

local function parse_yaml_file(filename)
    local file = io.open(filename, "r")
    if not file then
        error("Cannot open file: " .. filename)
    end
    
    local content = file:read("*all")
    file:close()
    
    local success, result = pcall(yaml.load, content)
    if not success then
        error("Invalid YAML: " .. result)
    end
    
    return result
end

-- 使用示例
local config = parse_yaml_file("config.yaml")
print(config.database.host)
```

## 数据验证

### 1. 模式验证

```lua
-- 配置验证器
local Validator = {}

function Validator.validate(config, schema)
    local function validate_type(value, expected_type)
        if expected_type == "string" then
            return type(value) == "string"
        elseif expected_type == "number" then
            return type(value) == "number"
        elseif expected_type == "boolean" then
            return type(value) == "boolean"
        elseif expected_type == "table" then
            return type(value) == "table"
        end
        return false
    end
    
    local function validate_value(value, rules)
        -- 类型检查
        if not validate_type(value, rules.type) then
            return false, string.format(
                "Expected %s, got %s",
                rules.type,
                type(value)
            )
        end
        
        -- 范围检查
        if rules.min and value < rules.min then
            return false, "Value too small"
        end
        if rules.max and value > rules.max then
            return false, "Value too large"
        end
        
        -- 模式匹配
        if rules.pattern and not string.match(value, rules.pattern) then
            return false, "Pattern not matched"
        end
        
        return true
    end
    
    local function validate_recursive(data, schema)
        for key, rules in pairs(schema) do
            local value = data[key]
            
            -- 检查必需字段
            if rules.required and value == nil then
                return false, "Missing required field: " .. key
            end
            
            -- 如果有值,验证它
            if value ~= nil then
                if rules.type == "table" and rules.properties then
                    -- 递归验证嵌套结构
                    local success, err = validate_recursive(
                        value,
                        rules.properties
                    )
                    if not success then
                        return false, key .. "." .. err
                    end
                else
                    -- 验证单个值
                    local success, err = validate_value(value, rules)
                    if not success then
                        return false, key .. ": " .. err
                    end
                end
            end
        end
        
        return true
    end
    
    return validate_recursive(config, schema)
end

-- 使用示例
local schema = {
    database = {
        type = "table",
        required = true,
        properties = {
            host = {
                type = "string",
                required = true
            },
            port = {
                type = "number",
                min = 1,
                max = 65535
            },
            user = {
                type = "string",
                required = true
            },
            password = {
                type = "string",
                required = true,
                pattern = "^.{8,}$"  -- 至少8个字符
            }
        }
    }
}

local success, err = Validator.validate(config, schema)
if not success then
    print("Validation failed: " .. err)
end
```

## 最佳实践

### 1. 配置缓存

```lua
-- 配置缓存管理器
local ConfigCache = {
    data = {},
    timestamps = {}
}

function ConfigCache.get(filename)
    local current_time = os.time()
    local last_time = ConfigCache.timestamps[filename]
    
    -- 检查文件是否被修改
    if last_time then
        local file_info = io.popen("stat -f %m " .. filename):read("*a")
        local mod_time = tonumber(file_info)
        
        if mod_time <= last_time then
            return ConfigCache.data[filename]
        end
    end
    
    -- 重新加载配置
    local config = load_config(filename)
    ConfigCache.data[filename] = config
    ConfigCache.timestamps[filename] = current_time
    
    return config
end
```

### 2. 环境变量支持

```lua
-- 环境变量解析器
local function parse_env_vars(config)
    local function replace_vars(value)
        if type(value) == "string" then
            return value:gsub("${([^}]+)}", function(var)
                return os.getenv(var) or ""
            end)
        end
        return value
    end
    
    local function process_table(t)
        local result = {}
        for k, v in pairs(t) do
            if type(v) == "table" then
                result[k] = process_table(v)
            else
                result[k] = replace_vars(v)
            end
        end
        return result
    end
    
    return process_table(config)
end

-- 使用示例
local config = {
    database = {
        host = "${DB_HOST}",
        user = "${DB_USER}",
        password = "${DB_PASS}"
    }
}

config = parse_env_vars(config)
```

### 3. 配置合并

```lua
-- 配置合并工具
local function merge_configs(base, override)
    local result = {}
    
    -- 复制基础配置
    for k, v in pairs(base) do
        if type(v) == "table" then
            result[k] = merge_configs(v, {})
        else
            result[k] = v
        end
    end
    
    -- 应用覆盖配置
    for k, v in pairs(override) do
        if type(v) == "table" and type(result[k]) == "table" then
            result[k] = merge_configs(result[k], v)
        else
            result[k] = v
        end
    end
    
    return result
end

-- 使用示例
local base_config = {
    database = {
        host = "localhost",
        port = 3306
    }
}

local dev_config = {
    database = {
        host = "dev.example.com"
    }
}

local config = merge_configs(base_config, dev_config)
```

## 常见问题

### Q1: 如何处理配置文件不存在的情况?

```lua
-- 配置加载器
local function load_config(filename, default_config)
    local file = io.open(filename, "r")
    if not file then
        if default_config then
            -- 使用默认配置
            return default_config
        else
            error("Config file not found: " .. filename)
        end
    end
    
    local content = file:read("*all")
    file:close()
    
    return load(content)()
end
```

### Q2: 如何实现配置热重载?

```lua
-- 配置监视器
local ConfigWatcher = {
    configs = {},
    callbacks = {}
}

function ConfigWatcher.watch(filename, callback)
    ConfigWatcher.configs[filename] = load_config(filename)
    ConfigWatcher.callbacks[filename] = callback
end

function ConfigWatcher.check_updates()
    for filename, old_config in pairs(ConfigWatcher.configs) do
        local new_config = load_config(filename)
        if not table.equals(old_config, new_config) then
            ConfigWatcher.configs[filename] = new_config
            ConfigWatcher.callbacks[filename](new_config)
        end
    end
end
```

### Q3: 如何保证配置安全性?

```lua
-- 配置加密工具
local function encrypt_config(config, key)
    local json = require("cjson")
    local data = json.encode(config)
    
    -- 使用AES加密
    local cipher = require("openssl.cipher")
    local aes = cipher.new("aes-256-cbc")
    return aes:encrypt(data, key)
end

local function decrypt_config(encrypted_data, key)
    local json = require("cjson")
    local cipher = require("openssl.cipher")
    
    local aes = cipher.new("aes-256-cbc")
    local data = aes:decrypt(encrypted_data, key)
    
    return json.decode(data)
end
```

## 下一步

现在你已经了解了如何处理配置文件,可以继续学习[自动化测试框架](/article/lua/practice/testing-framework)来了解如何进行Lua代码测试。

## 参考资源

- [Lua 5.4 参考手册](http://www.lua.org/manual/5.4/manual.html)
- [LuaFileSystem](https://keplerproject.github.io/luafilesystem/)
- [lua-cjson](https://www.kyne.com.au/~mark/software/lua-cjson.php)
- [lyaml](https://github.com/gvvaughan/lyaml)