Runtime

2018-04-26

都说Runtime是Objective-C中的黑魔法，这里有关于OC Runtime的详细介绍。而我们在用Swift的时候，很多时候也需要用到Runtime，它与在OC中的使用还是有一点点区别的。在解决UIButton重复点击问题时主要用到了Runtime中的关联对象(Associated Objects)和方法交叉(Method Swizzling)。

因为在Swift代码中已经没有了Objective-C的运行时消息机制, 在代码编译时即确定了其实际调用的方法. 所以纯粹的Swift类和对象没有办法使用runtime, 更不存在method swizzling. 那是不是在swift中就不能使用runtime了呢？答案肯定是可以的。要使用runtime，我们需要在想要使用runtime的方法或者属性前面加上**dynamic关键字。**

Associated Objects

在解决UIButton重复点击问题时，首先我们需要两个变量，一个是点击的间隔时间，另一个是是否需要忽视点击事件的Bool值，那么我们就需要将这两个变量与UIButton关联起来。

extension UIButton {
    
    private struct AssociatedKeys {
        static var clickDurationTime = "my_clickDurationTime"
        static var isIgnoreEvent = "my_isIgnoreEvent"
    }
    
    // 点击间隔时间
    var clickDurationTime : NSTimeInterval {
        set {
            objc_setAssociatedObject(self, &AssociatedKeys.clickDurationTime, newValue as NSTimeInterval, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
        
        get {
            
            if let clickDurationTime = objc_getAssociatedObject(self, &AssociatedKeys.clickDurationTime) as? NSTimeInterval {
                return clickDurationTime
            }
            
            return defaultDuration
        }
    }
    
    // 是否忽视点击事件
    var isIgnoreEvent : Bool {
        
        set {
            objc_setAssociatedObject(self, &AssociatedKeys.isIgnoreEvent, newValue as Bool, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
        
        get {
            
            if let isIgnoreEvent = objc_getAssociatedObject(self, &AssociatedKeys.isIgnoreEvent) as? Bool {
                return isIgnoreEvent
            }
            
            return false
        }
    }
}

Method Swizzling

接下来我们需要写一个用来替换UIButton点击事件的方法，在这个方法里来处理重复点击的问题。UIButton继承自UIControl，在传递点击事件是会触发这个方法：

1	public func sendAction(action: Selector, to target: AnyObject?, forEvent event: UIEvent?)

于是我们重写用来交叉的方法：

// SwizzledMethod
    func my_sendAction(action: Selector, to target: AnyObject?, forEvent event: UIEvent?) {
        
        if self.isKindOfClass(UIButton) {
            
            clickDurationTime = clickDurationTime == 0 ? defaultDuration : clickDurationTime
            
            if isIgnoreEvent {
                return
            } else if clickDurationTime > 0 {
                isIgnoreEvent = true
                // 在过了我们设置的duration之后，再将isIgnoreEvent置为false
                dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(clickDurationTime) * Int64(NSEC_PER_SEC)), dispatch_get_main_queue()) {
                    self.isIgnoreEvent = false
                }
                
                my_sendAction(action, to: target, forEvent: event)
            }
        } else {
            my_sendAction(action, to: target, forEvent: event)
        }
    }

接下来，就是用我们自己重写的SwizzeldMethod来替换UIButton的OriginalMethod：

// swift现不支持重写+load方法
    override public class func initialize() {
        struct Static {
            static var token: dispatch_once_t = 0
        }
        
        if self !== UIButton.self {
            return
        }

        dispatch_once(&Static.token) {
            
            let originalSelector = #selector(UIButton.sendAction(_:to:forEvent:))
            let swizzledSelector = #selector(UIButton.my_sendAction(_:to:forEvent:))
            
            let originalMethod = class_getInstanceMethod(self, originalSelector)
            let swizzledMethod = class_getInstanceMethod(self, swizzledSelector)
            
            // 运行时为类添加我们自己写的my_sendAction(_:to:forEvent:)
            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)
            }
        }
    }

这个方法，就是在运行时将UIButton的sendAction(:to:forEvent:)替换为我们自己写的my_sendAction(:to:forEvent:)。

load vs. initialize

在 Swift 中 load 类方法永远不会被 runtime 调用，因此在+load方法中实现交叉就变成了不可能的事。出于安全性和一致性的考虑，我们必须确保相关的方法交叉在一个 dispatchonce 中，这样也是很安全的。还有一种方法，在 app delegate 中实现方法交叉， 不像上面通过类扩展进行方法交叉，而是简单地在 app delegate 的 application(:didFinishLaunchingWithOptions:) 方法调用时中执行相关代码也是可以的。基于对类的修改，这种方法应该就足够确保这些代码会被执行到。