8

我想使用方法调配，但我什至无法获得简单的示例来为我工作。我可能误解了这个概念是什么，但据我所知，它允许交换方法实现。

给定两种方法，A 和 B，我想交换它们的实现，以便调用 A 来执行 B。我遇到了一些 swizzling 的例子（example1和example2）。我用一个类创建了一个新项目来测试它。

class Swizzle: NSObject
{
    func method()
    {
        print("A");
    }
}

extension Swizzle
{
    override class func initialize()
    {
        struct Static
        {
            static var token: dispatch_once_t = 0;
        }

        // make sure this isn't a subclass
        if (self !== Swizzle.self)
        {
            return;
        }

        dispatch_once(&Static.token)
        {
            let originalSelector = Selector("method");
            let swizzledSelector = Selector("methodExt");

            let originalMethod = class_getInstanceMethod(self, originalSelector);
            let swizzledMethod = class_getInstanceMethod(self, swizzledSelector);

            print(method_getImplementation(originalMethod));
            print(method_getImplementation(swizzledMethod));

            let didAddMethod = class_addMethod(self, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));

            if didAddMethod
            {
                class_replaceMethod(self, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
            }
            else
            {
                method_exchangeImplementations(originalMethod, swizzledMethod);
            }

            print(method_getImplementation(originalMethod));
            print(method_getImplementation(swizzledMethod));
        }
    }

    func methodExt()
    {
        print("B");
    }
}

然后我尝试执行它

var s = Swizzle();
s.method();

预期的输出是“B”，但仍在打印“A”。正如您从我的代码中看到的那样，我已经包含IMP了混合操作之前和之后的每个打印件。这些打印显示交换确实发生了，但输出保持不变。

输出：

0x000000010251a920
0x000000010251ad40
0x000000010251ad40
0x000000010251a920
A

在使这些更改生效时，我有什么遗漏吗？

PS。目前使用 XCode 7.0.1

4

1 回答 1

16

问题是您method()缺少dynamic指令：

class Swizzle: NSObject
{
    dynamic func method()
    {
        print("A")
    }
}

修改声明，它应该可以工作。

在 Swift 中使用方法调配时，您的类/方法必须遵守两个要求：

  • 您的课程必须扩展NSObject
  • 您要调配的函数必须具有该dynamic属性

有关为什么需要这样做的完整解释，请查看Using Swift with Cocoa and Objective-C：

需要动态调度

虽然该@objc属性将您的 Swift API 公开给 Objective-C 运行时，但它不保证属性、方法、下标或初始化程序的动态调度。Swift 编译器仍然可以去虚拟化或内联成员访问以优化代码的性能，绕过 Objective-C 运行时。当您使用修饰符标记成员声明时dynamic，始终动态调度对该成员的访问。因为使用dynamic修饰符标记的声明是使用 Objective-C 运行时调度的，所以它们被隐式标记为@objc属性。

很少需要动态调度。但是，当您知道 API 的实现在运行时被替换时，您必须使用dynamic修饰符。例如，您可以 method_exchangeImplementations在应用程序运行时使用 Objective-C 运行时中的函数来交换方法的实现。如果 Swift 编译器内联了方法的实现或对它的虚拟化访问，则不会使用新的实现。

斯威夫特 3 更新：

GCD 发生了一些变化，dispatch_once不再可用。为了执行相同的一次性操作，我们可以将代码封装在全局静态类常量的初始化块中。

Swift 语言保证此代码在应用程序的生命周期内只执行一次。

class TestSwizzling : NSObject {
    dynamic func methodOne()->Int{
        return 1
    }
}

extension TestSwizzling {

    //In Objective-C you'd perform the swizzling in load(), 
    //but this method is not permitted in Swift
    override class func initialize()
    {

        struct Inner {
            static let i: () = {

                let originalSelector = #selector(TestSwizzling.methodOne)
                let swizzledSelector = #selector(TestSwizzling.methodTwo)                 
                let originalMethod = class_getInstanceMethod(TestSwizzling.self, originalSelector);
                let swizzledMethod = class_getInstanceMethod(TestSwizzling.self, swizzledSelector)                
                method_exchangeImplementations(originalMethod, swizzledMethod)
            }
        }
        let _ = Inner.i
    }

    func methodTwo()->Int{
        // It will not be a recursive call anymore after the swizzling
        return methodTwo()+1
    }
}

var c = TestSwizzling()
print(c.methodOne())
print(c.methodTwo())

斯威夫特 2.2 更新：

我已经更新了新#selector属性的原始示例：

class TestSwizzling : NSObject {
    dynamic func methodOne()->Int{
        return 1
    }
}

extension TestSwizzling {

    //In Objective-C you'd perform the swizzling in load(), 
    //but this method is not permitted in Swift
    override class func initialize()
    {
        struct Static
        {
            static var token: dispatch_once_t = 0
        }

        // Perform this one time only
        dispatch_once(&Static.token)
        {
                let originalSelector = #selector(TestSwizzling.methodOne)
                let swizzledSelector = #selector(TestSwizzling.methodTwo)                 
                let originalMethod = class_getInstanceMethod(self, originalSelector);
                let swizzledMethod = class_getInstanceMethod(self, swizzledSelector)                
                method_exchangeImplementations(originalMethod, swizzledMethod)
        }
    }

    func methodTwo()->Int{
        // It will not be a recursive call anymore after the swizzling
        return methodTwo()+1
    }
}

var c = TestSwizzling()
print(c.methodOne())
print(c.methodTwo())

如果您需要一个示例，请查看github 上的这个示例项目。

于 2015-10-13T08:23:18.007 回答