XLua——热更新

钟进光

已于 2022-06-12 23:14:35 修改

阅读量1.1k

点赞数 2

分类专栏： xlua学习文章标签： lua 开发语言

于 2022-06-12 23:07:23 首次发布

本文链接：https://blog.csdn.net/qq_33218137/article/details/125246456

版权

xlua学习专栏收录该内容

2 篇文章 0 订阅

订阅专栏

什么是热更新？

游戏上线后，出现游戏Bug或者需要更新小版本内容，游戏如果没有做热更新支持的话，就需要重重新打包游戏，然后上传平台进行审核，审核通过后玩家才可以下载新版本。审核期间需要时间，而且频繁的重新去下载游戏新包，玩家可能会反感，造成玩家流失。

游戏有热更新技术的支持下，不用重新打包上传平台审核，然后发布游戏，让玩家去下载新版本。将资源放在服务器上，通过下载更新游戏内容或者修复游戏Bug。

https://github.com/Tencent/xLua

接入XLua框架我们可以很容易的实现代码的热补丁（热更新）

热补丁

侵入性小，老项目原有代码不做任何调整就可使用。
运行时影响小，不打补丁基本和原来程序一样。
出问题了可以用Lua来打补丁，这是才走lua代码逻辑

XLua热补丁使用方式

1.打开该特性

添加HOTFIX_ENABLE宏，（在Unity3D的File->Build Setting->Scripting Define Symbols下添加）。编辑器、各手机平台这个宏要分别设置！如果是自动化打包，要注意在代码里头用API设置的宏是不生效的，需要在编辑器设置。

建议平时开发业务代码不打开HOTFIX_ENABLE，只在build手机版本或者要在编译器下开发补丁时打开HOTFIX_ENABLE）

2、执行XLua/Generate Code菜单。

3、注入。

构建手机包这个步骤会在构建时自动进行，编辑器下开发补丁需要手动执行"XLua/Hotfix Inject In Editor"菜单。打印“hotfix inject finish!”或者“had injected!”才算成功，否则会打印错误信息。

如果已经打印了“hotfix inject finish!”或者“had injected!”，执行xlua.hotfix仍然报类似“xlua.access, no field __Hitfix0_Update”的错误，要么是该类没配置到Hotfix列表，要么是注入成功后，又触发了编译，覆盖了注入结果。

约束

不支持静态构造函数。
目前只支持Assets下代码的热补丁，不支持引擎，c#系统库的热补丁。

API

xlua.hotfix(class, [method_name], fix)

描述：注入lua补丁
class ： C#类，两种表示方法，CS.Namespace.TypeName或者字符串方式"Namespace.TypeName"，字符串格式和C#的Type.GetType要求一致，如果是内嵌类型（Nested Type）是非Public类型的话，只能用字符串方式表示"Namespace.TypeName+NestedTypeName"；
method_name ：方法名，可选；
fix：如果传了method_name，fix将会是一个function，否则通过table提供一组函数。table的组织按key是method_name，value是function的方式。

util.hotfix_ex(class, method_name, fix)

描述： xlua.hotfix的增强版本，可以在fix函数里头执行原来的函数，缺点是fix的执行会略慢。
method_name ：方法名；
fix ：用来替换C#方法的lua function。

打补丁

客户端测试过程中，只要修改了热补丁的代码，都需要重新进行hotfix注入

xlua可以用lua函数来替换C#的构造函数，函数，属性。事件的替换。lua实现都是函数，比如属性对于一个getter函数和一个setter函数，事件对应一个add函数和一个remove函数。

函数

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using XLua;


[Hotfix]
public class HotfixCalc : MonoBehaviour
{
    LuaEnv luaenv = new LuaEnv();
    void Start()
    {
        luaenv.DoString(@"
xlua.hotfix(CS.HotfixCalc, 'Add', function(self, a, b)
    return a + b
end)

xlua.hotfix(CS.HotfixCalc, 'staticAdd', function( a, b)
    return a + b
end)
            ");
        Debug.Log( "Add "+ Add(1, 1));
        Debug.Log("Add " + Add( Vector3.one, Vector3.one));
        Debug.Log("staticAdd " + HotfixCalc.staticAdd(1,1));
    }

    public int Add(int a, int b)
    {
        return a - b;
    }

    public Vector3 Add(Vector3 a, Vector3 b)
    {
        return a - b;
    }

    public static int staticAdd(int a, int b)
    {
        return a - b;
    }
}

输出

静态函数和成员函数的区别是，成员函数会加一个self，参数，这个self在Stateless方式下是C#对象本身（对应C#的this）
普通参数对于lua的参数，ref参数对应lua的一个参数和一个返回值，out参数对于lua的一个返回值。

构造函数

构造函数对应的method_name是‘.ctor’。
和普通函数不一样是，构造函数的热补丁并不是替换，而是执行原有逻辑后调用lua

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using XLua;
[Hotfix]
public class Hotfix构造函数 : MonoBehaviour
{
    LuaEnv luaenv = new LuaEnv();
    void Start()
    {
        HotfixTestClass1 oldTest = new HotfixTestClass1();
        luaenv.DoString(@"
xlua.hotfix(CS.HotfixTestClass1, '.ctor', function()
    print('新构造函数')
end)
            ");
        Debug.Log("------------------");
        HotfixTestClass1 newTest = new HotfixTestClass1();
    }
}
[Hotfix]
public class HotfixTestClass1
{
    public HotfixTestClass1()
    {
        Debug.Log("构造函数");
    }
}

析构函数

method_name是"Finalize"，传一个self参数。

和普通函数不一样的是，析构函数的热补丁并不是替换，而是开头调用lua函数后继续原有逻辑。

属性

using UnityEngine;
using XLua;

[Hotfix]
public class HotfixGetSet : MonoBehaviour
{
    public int age;
    public int Age
    {
        get { return age; }
        set { age = value; }
    }

    LuaEnv luaenv = new LuaEnv();
    void Start()
    {
        //get_属性名
        // set_属性名 
        luaenv.DoString(@"
                xlua.hotfix(CS.HotfixGetSet, 'get_Age', function()
                    return 10
                end)
                                                                                  
                xlua.hotfix(CS.HotfixGetSet, 'set_Age', function(self, value) -- value： 传入的值
                    print('set 属性')
                end)
            ");

        Debug.Log(Age);
        Age = 10;
    }
}

[]操作符

赋值对应set_Item，取值对应get_Item。第一个参数是self，赋值后面跟key，value，取值只有key参数，返回值是取出的值。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using XLua;
[Hotfix]
public class HotfixIndex : MonoBehaviour
{
    public int[] test = { 77, 88, 99, 100 };
    public int this[int index]
    {
        get { return test[index]; }
        set { test[index] = value; }
    }
    void Start()
    {
        LuaEnv luaenv = new LuaEnv();
        luaenv.DoString(@"
            -- 索引器
            --set_Item  get_Item
                xlua.hotfix(CS.HotfixIndex, 'set_Item', function(self, index, v)
                        print( tostring(index) .. '  ' .. tostring(v))
                        self.test[index] = v
                end)
                xlua.hotfix(CS.HotfixIndex, 'get_Item', function(self, index)
                        return self.test[index]
                end)
            ");
        this[1] = 20000;
        Debug.Log(this[1]);
    }
}

其它操作符

C#的操作符都有一套内部表示，比如+号的操作符函数名是op_Addition（其它操作符的内部表示可以去请参照相关资料），覆盖这函数就覆盖了C#的+号操作符。

事件

比如对于事件“AEvent”，+=操作符是add_AEvent，-=对应的是remove_AEvent。这两个函数均是第一个参数是self，第二个参数是操作符后面跟的delegate。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
using XLua;

[Hotfix]
[LuaCallCSharp]
public class HotfixAction : MonoBehaviour
{
    event UnityAction myEvent;
    void Start()
    {
        LuaEnv luaenv = new LuaEnv();
        luaenv.DoString(@"
                xlua.hotfix(CS.HotfixAction, 'add_myEvent', function(self, del)
--会去去尝试使用lua使用C#事件的方法去添加
 --在事件加减的重定向lua函数中
--千万不要把传入的委托往事件里存
--否则会死循环
-- self:myEvent('+', del)  ！！！！！！
--如果想重定向，肯定是希望把逻辑让lua处理
--所以一定是把传入的函数，存在lua的容器中
                    print('add_myEvent')               
                end)

                xlua.hotfix(CS.HotfixAction, 'remove_myEvent', function(self, del) 
                    print('remove_myEvent')
                end)
            ");

        myEvent += Test;
    }

    private void Test()
    {
        Debug.Log("xxxxxxxxxxxxxxx");
    }
}

泛化类型

其它规则一致，需要说明的是，每个泛化类型实例化后都是一个独立的类型，只能针对实例化后的类型分别打补丁。比如

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using XLua;
[Hotfix]
public class Hotfix泛型 : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        LuaEnv luaenv = new LuaEnv();
        luaenv.DoString(@"
        xlua.hotfix(CS.HotfixTest(CS.System.Int32), 'Test', function(self, str)
            print(' lua 中打的补丁 ' .. str )
        end)

            xlua.hotfix(CS.HotfixTest(CS.System.String), 'Test', function(self, str)
            print(' lua 中打的补丁 ' .. str )
        end)
");
        HotfixTest<int> hotfixTest = new HotfixTest<int>();
        hotfixTest.Test(1);

        HotfixTest<string> hotfixTest1 = new HotfixTest<string>();
        hotfixTest1.Test("string");

        HotfixTest<float> hotfixTest2 = new HotfixTest<float>();
        hotfixTest2.Test(1.5f);
    }
}
[Hotfix]
public class HotfixTest<T>
{
    public void Test(T str)
    {
        Debug.Log("该泛型未修改" + str);
    }
}

Unity协程

通过util.cs_generator 可以用一个function模拟一个Ienumerator,在里头用coroutine.yield,就类似C#里头yield return 。比如下面的C#代码和对应的hotfix代码是等同效果

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using XLua;

[Hotfix]
public class HotFixSubClass : MonoBehaviour
{
    void Awake()
    {
        LuaEnv luaenv = new LuaEnv();
        luaenv.DoString(@"
            -- xlua.hotfix(类， { 函数名 = 函数， 函数名 = 函数.....})
            local util = require 'xlua.util'   -- 要在lua中配合C#协程函数 必须使用它
            xlua.hotfix(CS.HotFixSubClass ,{
                    Start = function(self)
                    return util.cs_generator(function()
                        while true do
                            coroutine.yield(CS.UnityEngine.WaitForSeconds(3))
                            print('Wait for 3 seconds')
                        end
                    end)
                end;
                })
        ");
    }
    IEnumerator Start()
    {
        while (true)
        {
            yield return new WaitForSeconds(3);
            Debug.Log("Wait for 3 seconds");
        }
    }
}

整个类

如果要替换整个类，或者一个类中的多个方法，不需要一次次的调用xlua.hotfix去替换，可以整个一次完成。只要给一个table，按method_name = function组织即可

-- xlua.hotfix(类， { 函数名 = 函数，函数名 = 函数.....})


xlua.hotfix(CS.StatefullTest, {
    ['.ctor'] = function(csobj)
        return util.state(csobj, {evt = {}, start = 0, prop = 0})
    end;
    set_AProp = function(self, v)
        print('set_AProp', v)
        self.prop = v
    end;
    get_AProp = function(self)
        return self.prop
    end;
    get_Item = function(self, k)
        print('get_Item', k)
        return 1024
    end;
    set_Item = function(self, k, v)
        print('set_Item', k, v)
    end;
    add_AEvent = function(self, cb)
        print('add_AEvent', cb)
        table.insert(self.evt, cb)
    end;
    remove_AEvent = function(self, cb)
       print('remove_AEvent', cb)
       for i, v in ipairs(self.evt) do
           if v == cb then
               table.remove(self.evt, i)
               break
           end
       end
    end;
    Start = function(self)
        print('Start')
        for _, cb in ipairs(self.evt) do
            cb(self.start, 2)
        end
        self.start = self.start + 1
    end;
    StaticFunc = function(a, b, c)
       print(a, b, c)
    end;
    GenericTest = function(self, a)
       print(self, a)
    end;
    Finalize = function(self)
       print('Finalize', self)
    end
})

手游为什么要热更新，C#为什么不能热更新，LUA为什么可以 - 时空观察者9号 - 博客园

xLua/hotfix.md at master · Tencent/xLua · GitHub