Swift防止按钮重复点击实现+Swift如何运用Runtime
做过OC开发的都知道,我们想要给一个系统的类添加一个属性我们有几种方法,比如继承,我们创建一个父类,给父类写一个属性,之后所有使用的类都采用继承该父类的方式,这样就会都拥有该属性.更高级一点的我们会用到OC的Runtime的机制,
给分类添加属性，即使用 Runtime 中的 objc_setAssociatedObject 和 objc_getAssociatedObject
此外,我们还经常使用方法交换Method Swizzling,对一个既有的类进行方法交换,从而完成一些本来不能完成的事情,比如在viewDidAppear:方法调用的时候想要打印该类,我们通常就会采用方法交换的方式
比如我之前有写一个防止按钮重复点击的分类
之前是这么写的
#import <UIKit/UIKit.h>
#ifndef xlx_defaultInterval
#define xlx_defaultInterval 0.5 //默认时间间隔
#endif
@interface UIButton (Interval)
@property (nonatomic, assign) NSTimeInterval customInterval;//自定义时间间隔
@property (nonatomic, assign) BOOL ignoreInterval;//是否忽略间隔(采用系统默认)
@end
#import "UIButton+Interval.h"
#import <objc/runtime.h>
@implementation UIButton (Interval)
static const char *xlx_customInterval = "xlx_customInterval";
- (NSTimeInterval)customInterval {
return [objc_getAssociatedObject(self, xlx_customInterval) doubleValue];
}
- (void)setCustomInterval:(NSTimeInterval)customInterval {
objc_setAssociatedObject(self, xlx_customInterval, @(customInterval), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
static const char *xlx_ignoreInterval = "xlx_ignoreInterval";
-(BOOL)ignoreInterval {
return [objc_getAssociatedObject(self, xlx_ignoreInterval) integerValue];
}
-(void)setIgnoreInterval:(BOOL)ignoreInterval {
objc_setAssociatedObject(self, xlx_ignoreInterval, @(ignoreInterval), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
+ (void)load{
if ([NSStringFromClass(self.class) isEqualToString:@"UIButton"]) {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
SEL systemSel = @selector(sendAction:to:forEvent:);
SEL swizzSel = @selector(mySendAction:to:forEvent:);
Method systemMethod = class_getInstanceMethod([self class], systemSel);
Method swizzMethod = class_getInstanceMethod([self class], swizzSel);
BOOL isAdd = class_addMethod(self, systemSel, method_getImplementation(swizzMethod), method_getTypeEncoding(swizzMethod));
if (isAdd) {
class_replaceMethod(self, swizzSel, method_getImplementation(systemMethod), method_getTypeEncoding(systemMethod));
}else{
method_exchangeImplementations(systemMethod, swizzMethod);
}
});
}
}
- (void)mySendAction:(SEL)action to:(id)target forEvent:(UIEvent *)event{
if (!self.ignoreInterval) {
[self setUserInteractionEnabled:NO];
[self performSelector:@selector(resumeUserInteractionEnabled) withObject:nil afterDelay:self.customInterval>0?self.customInterval:xlx_defaultInterval];
}
[self mySendAction:action to:target forEvent:event];
}
-(void)resumeUserInteractionEnabled{
[self setUserInteractionEnabled:YES];
}
@end
这里有采用OC的Runtime机制来构造多个属性,和交换sendAction:to:forEvent: 从而完成在点击按钮的时候使其禁用某个间隔时间,以此来防止按钮重复点击造成误触
不能说特别好,但起码是一个比较优秀的写法,这样我们在创建一个按钮的时候我们就不用在乎其他,每一个按钮都会有一个默认的点击间隔,防止重复点击.
我们尝试采用Swift的方式来写看看
extension DispatchQueue {
static var `default`: DispatchQueue { return DispatchQueue.global(qos: .`default`) }
static var userInteractive: DispatchQueue { return DispatchQueue.global(qos: .userInteractive) }
static var userInitiated: DispatchQueue { return DispatchQueue.global(qos: .userInitiated) }
static var utility: DispatchQueue { return DispatchQueue.global(qos: .utility) }
static var background: DispatchQueue { return DispatchQueue.global(qos: .background) }
func after(_ delay: TimeInterval, execute closure: @escaping () -> Void) {
asyncAfter(deadline: .now() + delay, execute: closure)
}
private static var _onceTracker = [String]()
public class func once(_ token: String, block:()->Void) {
objc_sync_enter(self)
defer { objc_sync_exit(self) }
if _onceTracker.contains(token) {
return
}
_onceTracker.append(token)
block()
}
}
extension UIButton {
private struct AssociatedKeys {
static var xlx_defaultInterval:TimeInterval = 0.5
static var xlx_customInterval = "xlx_customInterval"
static var xlx_ignoreInterval = "xlx_ignoreInterval"
}
var customInterval: TimeInterval {
get {
let xlx_customInterval = objc_getAssociatedObject(self, &AssociatedKeys.xlx_customInterval)
if let time = xlx_customInterval {
return time as! TimeInterval
}else{
return AssociatedKeys.xlx_defaultInterval
}
}
set {
objc_setAssociatedObject(self, &AssociatedKeys.xlx_customInterval, newValue as TimeInterval ,.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
}
var ignoreInterval: Bool {
get {
return (objc_getAssociatedObject(self, &AssociatedKeys.xlx_ignoreInterval) != nil)
}
set {
objc_setAssociatedObject(self, &AssociatedKeys.xlx_ignoreInterval, newValue as Bool, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
}
override open class func initialize() {
if self == UIButton.self {
DispatchQueue.once(NSUUID().uuidString, block: {
let systemSel = #selector(UIButton.sendAction(_:to:for:))
let swizzSel = #selector(UIButton.mySendAction(_:to:for:))
let systemMethod = class_getInstanceMethod(self, systemSel)
let swizzMethod = class_getInstanceMethod(self, swizzSel)
let isAdd = class_addMethod(self, systemSel, method_getImplementation(swizzMethod), method_getTypeEncoding(swizzMethod))
if isAdd {
class_replaceMethod(self, swizzSel, method_getImplementation(systemMethod), method_getTypeEncoding(systemMethod));
}else {
method_exchangeImplementations(systemMethod, swizzMethod);
}
})
}
}
private dynamic func mySendAction(_ action: Selector, to target: Any?, for event: UIEvent?) {
if !ignoreInterval {
isUserInteractionEnabled = false
DispatchQueue.main.after(customInterval) { [weak self] in
self?.isUserInteractionEnabled = true
}
}
mySendAction(action, to: target, for: event)
}
}
一切都是并不是那么麻烦
但是要注意的是Objective-C runtime 理论上会在加载和初始化类的时候调用两个类方法： load and initialize。在讲解 method swizzling 的原文中 Mattt 老师指出出于安全性和一致性的考虑，方法交叉过程 永远 会在 load() 方法中进行。每一个类在加载时只会调用一次 load 方法。另一方面，一个 initialize 方法可以被一个类和它所有的子类调用，比如说 UIViewController 的该方法，如果那个类没有被传递信息，那么它的 initialize 方法就永远不会被调用了。
不幸的是，在 Swift 中 load 类方法永远不会被 runtime 调用，因此方法交叉就变成了不可能的事。我们只能在 initialize 中实现方法交叉，你只需要确保相关的方法交叉在一个 dispatch_once 中就好了(这也是最推荐的做法)。
不过，Swift使用Method Swizzling需要满足两个条件
包含 swizzle 方法的类需要继承自 NSObject
需要 swizzle 的方法必须有动态属性（dynamic attribute）
通常添加下，我们都是交换系统类的方法，一般不需要关注着两点。但是如果我们自定义的类，也需要交换方法就要满足这两点了（ 这种状况是极少的，也是应该避免的 ）
表面上来看,感觉并没有什么,那么我们做个Swift的Runtime的动态分析
我们拿一个纯Swift类和一个继承自NSObject的类来做分析，这两个类里包含尽量多的Swift的类型。
首先动态性比较重要的一点就是能够拿到某个类所有的方法、属性
import UIKit
class SimpleSwiftClass {
var aBool:Bool = true
var aInt:Int = 10
var aDouble:Double = 3.1415926
var aString:String = "SimpleSwiftClass"
var aObj:AnyObject! = nil
func testNoReturn() {
}
}
class ViewController: UIViewController {
var aBool:Bool = true
var aInt:Int = 10
var aDouble:Double = 3.1415926
var aString:String = "SimpleSwiftClass"
var aObj:AnyObject! = nil
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
let aSwiftClass:SimpleSwiftClass = SimpleSwiftClass();
showClassRuntime(object_getClass(aSwiftClass));
print("\n");
showClassRuntime(object_getClass(self));
}
func testNoReturn() {
}
func testReturnBool() -> Bool {
return true;
}
func testReturnInt() -> Int {
return 10;
}
func testReturnDouble() -> Double {
return 10.1111;
}
func testReturnString() -> String {
return "a boy";
}
//OC中没有的TypeEncoding
func testReturnTuple() -> (Bool,String) {
return (true,"aaa");
}
func testReturnCharacter() -> Character {
return "a";
}
}
func showClassRuntime(_ aclass:AnyClass) {
print(aclass)
print("start methodList")
var methodNum:UInt32 = 0
let methodList = class_copyMethodList(aclass, &methodNum)
for index in 0..<numericCast(methodNum) {
let method:Method = methodList![index]!
print(method_getName(method))
}
print("end methodList")
print("start propertyList")
var propertyNum:UInt32 = 0
let propertyList = class_copyPropertyList(aclass, &propertyNum)
for index in 0..<numericCast(propertyNum) {
let property:objc_property_t = propertyList![index]!
print(String(utf8String: property_getName(property)) ?? "")
}
print("end propertyList")
}
我们运行看看结果
对于纯Swift的SimpleSwiftClass来说任何方法、属性都未获取到
对于ViewController来说除testReturnTuple、testReturnCharacter两个方法外，其他的都获取成功了。
为什么会发生这样的问题呢?
1.纯Swift类的函数调用已经不再是Objective-C的运行时发消息，而是类似C++的vtable，在编译时就确定了调用哪个函数，所以没法通过Runtime获取方法、属性。
2.ViewController继承自UIViewController，基类为NSObject，而Swift为了兼容Objective-C，凡是继承自NSObject的类都会保留其动态性，所以我们能通过Runtime拿到他的方法。
3.从Objective-c的Runtime 特性可以知道，所有运行时方法都依赖TypeEncoding，而Character和Tuple是Swift特有的，无法映射到OC的类型，更无法用OC的typeEncoding表示，也就没法通过Runtime获取了。
再来就是方法交换Method Swizzling
上面已经展示了一个防止重复点击按钮的方法交换的例子.
那么就没有一点问题吗?
我们就拿现在的ViewController来举个例子
func methodSwizze(cls:AnyClass, systemSel:Selector,swizzeSel:Selector) {
let systemMethod = class_getInstanceMethod(cls, systemSel)
let swizzeMethod = class_getInstanceMethod(cls, swizzeSel)
let isAdd = class_addMethod(cls, systemSel, method_getImplementation(swizzeMethod), method_getTypeEncoding(swizzeMethod))
if isAdd {
class_replaceMethod(cls, swizzeSel, method_getImplementation(systemMethod), method_getTypeEncoding(systemMethod));
}else {
method_exchangeImplementations(systemMethod, swizzeMethod);
}
}
先写一个交换方法
然后运行交换方法看看
运行
很显然交换成功,当系统调用viewDidAppear的时候会交换到myViewDidAppear,
那么我们如果运行myViewDidAppear?是不是会交换到viewDidAppear?
看看运行结果交换失败了
查阅Swift3.0的文档(之所以不看2.X,不解释了,与时俱进)
dynamic 将属性或者方法标记为dynamic就是告诉编译器把它当作oc里的属性或方法来使用(runtime),
于是我们将方法和属性全部加上dynamic修饰
重新测试
此时的所有结果都跟OC的一样了,原因是什么上面也说了,因为Swift会做静态优化。要想完全被动态调用，必须使用dynamic修饰。
当你指定一个成员变量为 dynamic 时，访问该变量就总会动态派发了。因为在变量定义时指定 dynamic 后，会使用Objective-C Runtime来派发。
另外再补充一些,
1.Objective-C获取Swift runtime信息
使用在Objective-c代码里使用objc_getClass("SimpleSwiftClass");会发现返回值为空，是因为在OC中的类名已经变成SwiftRuntime.SimpleSwiftClass，即规则为SWIFT_MODULE_NAME.类名称，在普通源码项目里SWIFT_MODULE_NAME即为ProductName，在打好的Cocoa Touch Framework里为则为导出的包名。
所以想要获取信息使用
id cls = objc_getClass("SwiftRuntime.SimpleSwiftClass");
showClassRuntime(cls);
所以OC替换Swift的方法你应该也是会了,确保dynamic,确保类名的正确访问即可
2.你会发现initialize方法在Swift3以上会出现警告,表示未来可能会被废弃
那么我们也可以在 appdelegate 中实现方法交换,不通过类扩展进行方法交换，而是简单地在 appdelegate 的 application(_:didFinishLaunchingWithOptions:) 方法调用时中执行相关代码也是可以的。也可以单独写一个用于管理方法交换的单例类,在appdelegate中运行，基于对类的修改，这种方法应该就足够确保这些代码会被执行到。
