一、什么是Runtime：

Runtime是苹果开发中比extension更加强大的一项黑科技

extension允许用户在不修改原始代码的情况下，为类增加额外的方法

而Runtime则允许用户在不修改原始代码的情况下，为类增加额外的属性，甚至直接改变原有方法的实现

*Runtime在OC和Swift中都可以使用

二、方法交叉：Method Swizzling

1、为什么要用Method Swizzling

在实际应用中，我们可能会遇到这样的场景：

我们定义了很多Label控件，有些是在xib中定义的，有些是通过代码创建的

在这些Label中，有些使用的是系统默认字体，有些使用的则是自定义字体

然后有一天，设计师突然给了一个新字体，说所有的系统默认字体都应该替换成这个字体

虽然很不爽，但还是花了半天时间把系统中所有的Label字体都修改了一遍（可能有些还有遗漏）

然后又有一天，老板说这个字体不好看！给我换成另外一个字体！于是设计师又给了一个新字体

于是又花了半天时间把所有Label的字体再修改一遍，并且出现了更多的遗漏

就这样，我们浪费了很多时间在改字体上面，最后出来的效果还不尽人意

于是我们就心想，如果有一个方法，能够把所有Label的系统默认字体，都替换成我们想要的新字体该多好啊

这样，不管我们在xib中定义Label还是在代码中创建Label，都直接使用系统默认字体即可

即使要改字体的话，也直接修改这个方法中的字体就行，然后所有Label就都自动改过来了

当然，这个需求是可以实现的，但首先要有解决问题的思路：

思路一：每当程序需要获取系统默认字体时，直接返回我们想要的字体

思路二：每当Label被创建或加载时，判断当前Label的字体是否为系统字体，若是，则修改为我们想要的字体

那么问题来了，无论用哪种思路，都要求必须要修改系统原始控件中的方法，例如

思路一：需要修改UIFont的systemFontOfSize等方法，使其返回指定的字体

思路二：需要修改UILabel的awakeFromNib等方法，将其修改为指定的字体

但是，我们并不能直接修改UIFont和UILabel的代码，那么要如何实现我们想要的效果呢？

这就要用到Runtime中的Method Swizzling机制了

2、什么是Method Swizzling：

Swizzling的中文翻译是“交叉混合”，要想理解Method Swizzling机制，首先需要了解iOS中方法调用的原理

在iOS中，每个方法（或称为函数，下同）都是由方法的声明和方法的实现两部分来构成的

其中，方法的声明就是方法的名称和参数，而方法的实现就是方法中定义的代码

*为了简单起见，在下面的介绍中，方法的声明将简称为方法名，方法的实现将简称为方法体

在正常调用方法的时候，我们通常是将两者作为一个整体调用的，即通过方法名直接调用方法体

但实际上，方法名和方法体是两个不同的对象，方法名的对象类型为Selector，而方法体的对象类型则为Method

当我们调用一个方法时，系统首先会找到该方法对应的Selector，然后再根据Selector找到对应的Method

当然，我们也可以直接提供给系统一个Selector，系统也可以通过该Selector找到对应的Method

但是，如果我们把一个方法的Selector，指向另一个方法的Method，那会怎样呢？

为了理解这个概念，我们首先看看下面这个类：

class SwizzlingDemo {
    func printA() {
        print("A")
    }
    
    func printB () {
        print("B")
    }
}

很明显：

当我们调用printA()的时候，控制台就会打印A

当我们调用printB()的时候，控制台就会打印B

那么，我们能不能在 完全不修改这个类的任何代码的前提下

在调用printA()的时候，让控制台打印B

而调用printB()的时候，让控制台打印A呢？

这样就需要用到Method Swizzling了

Method Swizzling，其作用就是 在不修改任何代码的前提下，交换两个方法的声明与实现

为了实现上述需求，我们首先需要使用extension，对SwizzlingDemo进行扩展：

extension Swizzling Demo {    
   class func swizzlePrintMethod() {
        //获取printA和printB的Selector
        let printASelector = #selector(SwizzlingDemo.printA)
        let printBSelector = #selector(SwizzlingDemo.printB)
        
        //获取printA和printB的Method
        let printAMethod = class_getInstanceMethod(self,printASelector)
        let printBMethod = class_getInstanceMethod(self,printBSelector)
        
        //交换两个方法的Method
        method_exchangeImplementations(printAMethod,printBMethod)
    }
}

我们在SwizzlingDemo中扩展了一个方法：swizzlePrintMethod()

从代码中可以很清晰地看出：

我们首先获取了printA和printB两个方法的Selector

再根据两个Selector取出了两个方法的Method

最后交换了两个方法的Method，Swizzing完毕。

是的，就是这么简单。

执行了这段代码之后，当我们再调用printA的时候

系统实际上执行的就是printB的Method，也就是在控制台打印B了

所以，问题就变成了，我们应该在什么时候调用这个方法呢？

一个最推荐（也是最安全）的做法是：

重写这个类的initialize方法，并且通过dispatch_once仅调用一次，如下：

extension SwizzlingDemo {
    //首先我们需要重写initialize方法，当系统在加载这个类的时候就会执行其中的代码
    override class func initialize() {
       //创建单次标识（固定写法，照抄即可）
       struct Static {
           static var token: dispatch_once_t =0
       }
        
       //使用单次标识代码块，确保其中的代码仅执行一次（固定写法，照抄即可）
       //*重要！*此代码块不可省略！否则会产生不可预知的崩溃！
       dispatch_once(&Static.token) {
           //若对象类型正确，则执行Swizzle方法
           if self == SwizzlingDemo.self {
               swizzlePrintMethod()
           }
        }
    }
}

由于initialize方法会在系统加载这个类的时候被调用

因此，我们就可以确保我们的代码在最初的时候就可以执行，且仅执行一次

*注：在OC的开发中，一般是在load方法中执行Swizzling的

但Swift从1.2版本之后就不再支持load方法，因此只能重写initialize方法

这样，我们就通过extension完成了一次完整的Swizzling

当我们在程序中任何其他地方调用这个对象的printA方法时，控制台打印的将始终是B

3、使用Method Swizzling解决问题：

那么回到我们最初的问题

如果我们想要在不修改UIFont和UILabel代码的前提下加入我们想要的操作，要如何做呢？

代码实现的基本原理还是一样的，为了简单起见，在此只以UILabel的awakeFromNib方法为例

首先，我们需要在UILabel中，新定义一个可以修改系统默认字体的方法：

// MARK: - New Font Methods
extension UILabel {
   //方法名随意，但由于准备替换掉系统的awakeFromNib方法，因此如此命名
   @objc func myAwakeFromNib() {     
        //仅替换掉系统默认字体，不修改其他字体
       if self.font.fontDescriptor().postscriptName == ".SFUIText-Regular" {
           let font = UIFont(name: "FZLanTingKanHei-R-GBK",size: self.font.pointSize)
           self.font = font
       }
    }
}

然后，我们需要一段代码，使用自定义的方法替换掉系统的awakeFromNib方法：

extension UILabel { 
   private class func swizzleSystemLabel() {
       //获取两个awakeFromNib方法的声明
       let systemAwakeFromNibSelector = #selector(UILabel.awakeFromNib)
       let myAwakeFromNibSelector = #selector(UILabel.myAwakeFromNib)

       //获取两个awakeFromNib方法的实现
       let systemAwakeFromNibMethod = class_getInstanceMethod(self,systemAwakeFromNibSelector)
       let myAwakeFromNibMethod = class_getInstanceMethod(self,myAwakeFromNibSelector)
       
       //交换两个方法的实现
       method_exchangeImplementations(systemAwakeFromNibMethod,myAwakeFromNibMethod)
   }
}

最后，我们需要重写UILabel的initialize方法，确保我们的swizzle方法被执行：

extension UILabel { 
   override public class func initialize() {
        struct Static {
            staticvar token: dispatch_once_t =0
        }
        
        dispatch_once(&Static.token) {
            if self == UILabel.self {
                swizzleSystemLabel()
            }
        }
    }
}

这样，当UILabel从xib文件中被加载的时候，系统会自动调用UILabel的awakeFromNib方法

但由于这个方法的实现已经被我们替换了，因此实际上执行的就是myAwakeFromNib方法的实现

从而用我们自定义的字体，来替换掉系统的默认字体了

4、使用Method Swizzling的注意事项：

由于Method Swizzling本质上是直接替换了两个方法的实现

因此，如果我们替换了一些有系统默认实现的方法（例如init方法），那要如何保证原有的实现也能够被调用呢？

答案并不难：在自定义方法的实现中，调用系统原有方法的实现就可以了

但是！（注意但是！）让我们看下面两个例子，想想到底哪个是正确的：

例子1：

@objc func myAwakeFromNib() {
   self.awakeFromNib()          //调用awakeFromNib方法
   ...
}

例子2：

@objc func myAwakeFromNib() {
   self.myAwakeFromNib()       //调用myAwakeFromNib方法
   ...
}

乍一看，似乎第一个例子是正确的，因为调用的就是系统原有的awakeFromNib方法嘛

但是，再仔细想一想，这个 方法体应该是什么时候，通过 哪个方法名被调用的呢？

答案就是，在程序运行的时候，通过awakeFromNib方法名被调用的

所以，正确答案应该是例子2

虽然看上去像是递归，实际上只是 貌合神离罢了

虽然现在看上去像是在一起，但只要程序一运行，当方法交换完成后，这个方法体就不再属于这个方法名了

在这个时候，myAwakeFromNib的方法体，事实上已经属于awakeFromNib这个方法名了

而系统原有的awakeFromNib这个方法的实现，则已经到了myAwakeFromNib这个方法名下了

三、关联对象：Associated Objects

资料来源：

Runtime详解： http://nshipster.cn/swift-objc-runtime/

使用Runtime全局修改UILabel的默认字体： http://my.oschina.net/u/2340880/blog/538356

使用Runtime全局修改UIFont的默认字体： https://gist.github.com/feighter09/721c270897efb9b7381d（注意有错误：未调用dispatch_once）