如何在Swift 3.0中实现方法交换？

Question

我怎样在 Swift 3.0 中实现方法交换？

我已经阅读了关于此的 nshipster 文章, 但是在这段代码中

struct Static {
    static var token: dispatch_once_t = 0
}

编译器给我一个错误

dispatch_once_t在Swift中不可用：使用延迟初始化的全局变量代替

- Tikhonov Aleksandr

---

错误信息有点晦涩，使用static变量是可以的，因为static变量只会被自动创建一次，这发生在它们第一次被访问时（即懒加载）。在Swift 3中，static var token = 0是正确的方法。来源 - BallpointBen

Answer 1

首先，Swift 3.0 中不可用 dispatch_once_t。您可以从以下两个替代品中选择：

1. 全局变量

2. struct、enum 或 class 的静态属性

有关更多详细信息，请参见Whither dispatch_once in Swift 3

对于不同的目的，必须使用不同的交换实现

• 交换CocoaTouch类，例如UIViewController;
• 交换自定义Swift类;

交换CocoaTouch类

示例：使用全局变量交换UIViewController的viewWillAppear(_:)

private let swizzling: (UIViewController.Type) -> () = { viewController in

    let originalSelector = #selector(viewController.viewWillAppear(_:))
    let swizzledSelector = #selector(viewController.proj_viewWillAppear(animated:))

    let originalMethod = class_getInstanceMethod(viewController, originalSelector)
    let swizzledMethod = class_getInstanceMethod(viewController, swizzledSelector)

    method_exchangeImplementations(originalMethod, swizzledMethod) }

extension UIViewController {

    open override class func initialize() {
        // make sure this isn't a subclass
        guard self === UIViewController.self else { return }
        swizzling(self)
    }

    // MARK: - Method Swizzling

    func proj_viewWillAppear(animated: Bool) {
        self.proj_viewWillAppear(animated: animated)

        let viewControllerName = NSStringFromClass(type(of: self))
        print("viewWillAppear: \(viewControllerName)")
    } 
 }

Swizzling自定义Swift类

要使用方法swizzling与您的Swift类，您必须遵守两个要求（更多细节）：

• 包含要交换方法的类必须扩展NSObject
• 您想交换的方法必须具有dynamic属性

一个示例是自定义Swift基类Person的swizzling方法

class Person: NSObject {
    var name = "Person"
    dynamic func foo(_ bar: Bool) {
        print("Person.foo")
    }
}

class Programmer: Person {
    override func foo(_ bar: Bool) {
        super.foo(bar)
        print("Programmer.foo")
    }
}

private let swizzling: (Person.Type) -> () = { person in

    let originalSelector = #selector(person.foo(_:))
    let swizzledSelector = #selector(person.proj_foo(_:))

    let originalMethod = class_getInstanceMethod(person, originalSelector)
    let swizzledMethod = class_getInstanceMethod(person, swizzledSelector)

    method_exchangeImplementations(originalMethod, swizzledMethod)
}

extension Person {

    open override class func initialize() {
        // make sure this isn't a subclass
        guard self === Person.self else { return }
        swizzling(self)
    }

    // MARK: - Method Swizzling

    func proj_foo(_ bar: Bool) {
        self.proj_foo(bar)

        let className = NSStringFromClass(type(of: self))
        print("class: \(className)")
    }
}

- Tikhonov Aleksandr

---

在这种情况下，class_addMethod() 何时会返回 true？因为 Swift 的 #selector 要求关联的方法存在，所以 originalSelector 总是存在的，导致 class_addMethod “失败”。我发现只包含对 method_exchangeImplementations() 的调用是安全的，可以省略对 classAddMethod() 和 class_replaceMethod() 的调用。 - Kevin Owens

未来版本的Swift将禁用ˆinitialize()方法。 Swift 3.1更新记录：当NSObject子类尝试重写类初始化方法时，Swift现在会发出警告。 Swift不能保证对类名的引用触发Objective-C类实例化，如果它们没有其他副作用，则会导致Swift代码尝试重写initialize时出现错误。 - Alessandro

@Alessandro，在这些限制下如何执行 method swizzling，你有什么建议？ - Alexander Telegin

颠簸。有什么关于下一个最佳地点执行 swizzle 的想法吗？ - MikeyWard

你可以在应用程序委托中添加一个方法，当调用application(_:didFinishLaunchingWithOptions:)时执行。请查看Kickstarter App repo中的AppDelegate；特别是UIViewController.doBadSwizzleStuff()的实现。@ilan - Alessandro

Answer 2

@TikhonovAlexander: 好的回答。

我修改了Swizzler，使其接受两个选择器并使其更加通用。

Swift 4 / Swift 5

private let swizzling: (AnyClass, Selector, Selector) -> () = { forClass, originalSelector, swizzledSelector in
    guard
        let originalMethod = class_getInstanceMethod(forClass, originalSelector),
        let swizzledMethod = class_getInstanceMethod(forClass, swizzledSelector)
    else { return }
    method_exchangeImplementations(originalMethod, swizzledMethod)
}

extension UIView {
    
    static let classInit: Void = {            
        let originalSelector = #selector(layoutSubviews)
        let swizzledSelector = #selector(swizzled_layoutSubviews)
        swizzling(UIView.self, originalSelector, swizzledSelector)
    }()
    
    @objc func swizzled_layoutSubviews() {
        swizzled_layoutSubviews()
        print("swizzled_layoutSubviews")
    }
    
}

// perform swizzling in AppDelegate.init()

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    override init() {
        super.init()
        UIView.classInit
    }

}

Swift 3

private let swizzling: (AnyClass, Selector, Selector) -> () = { forClass, originalSelector, swizzledSelector in
    let originalMethod = class_getInstanceMethod(forClass, originalSelector)
    let swizzledMethod = class_getInstanceMethod(forClass, swizzledSelector)
    method_exchangeImplementations(originalMethod, swizzledMethod)
}

// perform swizzling in initialize()

extension UIView {
    
    open override class func initialize() {
        // make sure this isn't a subclass
        guard self === UIView.self else { return }
        
        let originalSelector = #selector(layoutSubviews)
        let swizzledSelector = #selector(swizzled_layoutSubviews)
        swizzling(self, originalSelector, swizzledSelector)
    }
    
    func swizzled_layoutSubviews() {
        swizzled_layoutSubviews()
        print("swizzled_layoutSubviews")
    }
    
}

- efremidze

---

这不是一种安全的方法来交换方法，原因在这里详细阐述：https://blog.newrelic.com/2014/04/16/right-way-to-swizzle/ - Werner Altewischer

为什么你使用块而不是方法？因为你只是把一些东西复制在一起，你并不理解。块被使用是因为博客文章中解释的原因...你实现它的方式只是绕过了它，使其变得无用。不要采用某些东西，因为别人这样做了，而不理解他们为什么这样做。 - hashier

@hashier，你为什么要争论块或方法？据我所知，使用classInit块是可以的，它可以保证classInit只能被执行一次。你能否给我展示一下你提到的帖子链接？ - DàChún

@User9527，对的，这个块只会被执行一次，但是它在这里被用作方法。因此，对于您只想执行一次的部分，使用块是有意义的，但您调用的方法可以是普通方法，因此您可以再次进行方法交换。 - hashier

Swift 4编译不通过。您需要在“swizzled_layoutSubviews”中添加@objc，并对“swizzling”内部的方法进行可选检查。 - Jonny

Answer 3

游戏中的Swizzling
Swift 5

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

extension TestSwizzling {
    @objc func methodTwo()->Int{
        // It will not be a recursive call anymore after the swizzling
        return 2
    }
    //In Objective-C you'd perform the swizzling in load(),
    //but this method is not permitted in Swift
    func swizzle(){
        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!)
            print("swizzled!")
        }
        i()
    }
}

var c = TestSwizzling()
print([c.methodOne(), c.methodTwo()])  // [1, 2]
c.swizzle()                            // swizzled!
print([c.methodOne(), c.methodTwo()])  // [2, 1]

- Dharay

---

结果打印([c.methodOne(), c.methodTwo()]) ==> // [1, 2]。因为您声明了methodTwo()返回2。请更新您的代码以避免误导。 - Giang

Answer 4

Swift swizzling（交换）

@objcMembers
class sA {
    dynamic
    class func sClassFooA() -> String {
        return "class fooA"
    }
    
    dynamic
    func sFooA() -> String {
        return "fooA"
    }
}

@objcMembers
class sB {
    dynamic
    class func sClassFooB() -> String {
        return "class fooB"
    }
    
    dynamic
    func sFooB() -> String {
        return "fooB"
    }
}

Swizzling.swift

import Foundation

@objcMembers
public class Swizzling: NSObject {
    
    public class func sExchangeClass(cls1: AnyClass, sel1: Selector, cls2: AnyClass, sel2: Selector) {
        
        let originalMethod = class_getClassMethod(cls1, sel1)
        let swizzledMethod = class_getClassMethod(cls2, sel2)
        
        method_exchangeImplementations(originalMethod!, swizzledMethod!)
    }

    public class func sExchangeInstance(cls1: AnyClass, sel1: Selector, cls2: AnyClass, sel2: Selector) {
        
        let originalMethod = class_getInstanceMethod(cls1, sel1)
        let swizzledMethod = class_getInstanceMethod(cls2, sel2)
        
        method_exchangeImplementations(originalMethod!, swizzledMethod!)
    }
}

使用 Swift：

func testSExchangeClass() {
    Swizzling.sExchangeClass(cls1: sA.self, sel1: #selector(sA.sClassFooA), cls2: sB.self, sel2: #selector(sB.sClassFooB))
    
    XCTAssertEqual("class fooB", sA.sClassFooA())
}

func testSExchangeInstance() {
    Swizzling.sExchangeInstance(cls1: sA.self, sel1: #selector(sA.sFooA), cls2: sB.self, sel2: #selector(sB.sFooB))
    
    XCTAssertEqual("fooB", sA().sFooA())
}

[将Objective-C添加为消费者]

通过Objective-C使用

- (void)testSExchangeClass {
    [Swizzling sExchangeClassWithCls1:[cA class] sel1:@selector(cClassFooA) cls2:[cB class] sel2:@selector(cClassFooB)];
    
    XCTAssertEqual(@"class fooB", [cA cClassFooA]);
}

- (void)testSExchangeInstance {
    [Swizzling sExchangeInstanceWithCls1:[cA class] sel1:@selector(cFooA) cls2:[cB class] sel2:@selector(cFooB)];
    
    XCTAssertEqual(@"fooB", [[[cA alloc] init] cFooA]);
}

[Objective-C方法替换]

- yoAlex5

Answer 5

Swift 5.1

Swift使用Objective-C运行时特性来进行方法交换。这里有两种方法。

注意：open override class func initialize() {}不再被允许使用。

类继承 `NSObject`，方法必须有 `dynamic` 属性

``` class Father: NSObject { @objc dynamic func makeMoney() { print("make money") } } extension Father { static func swizzle() { let originSelector = #selector(Father.makeMoney) let swizzleSelector = #selector(Father.swizzle_makeMoney) let originMethod = class_getInstanceMethod(Father.self, originSelector) let swizzleMethod = class_getInstanceMethod(Father.self, swizzleSelector) method_exchangeImplementations(originMethod!, swizzleMethod!) } @objc func swizzle_makeMoney() { print("have a rest and make money") } } Father.swizzle() var tmp = Father() tmp.makeMoney() // have a rest and make money tmp.swizzle_makeMoney() // make money ```

使用 `@_dynamicReplacement(for: )`

``` class Father { dynamic func makeMoney() { print("make money") } } extension Father { @_dynamicReplacement(for: makeMoney()) func swizzle_makeMoney() { print("have a rest and make money") } } Father().makeMoney() // have a rest and make money ```

- mistdon

---

如果我在一个pod中使用@_dynamicReplacement (for:)，当我在模拟器中运行它时，会出现错误："unsupported relocation with subtraction expression, symbol '' can not be undefined in a subtraction expression"。有没有解决或避免这个问题的方法？ - Rakuyo

我问了这个问题。 - Rakuyo

Answer 6

尝试使用这个框架：https://github.com/623637646/SwiftHook

let object = MyObject()
let token = try? hookBefore(object: object, selector: #selector(MyObject.noArgsNoReturnFunc)) {
    // run your code
    print("hooked!")
}
object.noArgsNoReturnFunc()
token?.cancelHook() // cancel the hook

在Swift中挂钩方法非常容易。

- Yanni