写在前面
经过激烈的思想斗争，笔者从Android开发转到了iOS开发，发现了两者很多的共同之处，这里就不在赘述；不过最大的不适应体现在UI方面，Android的布局编写和预览更舒适。
万般无奈之下，接触到了SnapKit，一个用Swift编写的AutoLayout框架，极大程度上简化了纯布局的代码。
分析源码
本文只探究makeConstraints的过程，也就是停留在闭包之外。
ConstraintView
SnapKit的最基本用法：
view.snp.makeConstraints { (make) in
}
首先view.snp很容易让人想到是使用了扩展，但并不是直接对UIView的扩展，而是要引入一个新的概念ConstraintView，具体情况在ConstraintView.swift中体现：
#if os(iOS) || os(tvOS)
import UIKit
#else
import AppKit
#endif
#if os(iOS) || os(tvOS)
public typealias ConstraintView = UIView
#else
public typealias ConstraintView = NSView
#endif
这就是该文件所有的代码了，可以看到，通过判断当前系统做了两件事：
- 包的导入：如果当前系统是
iOS或者tvOS，那么导入UIKit，否则导入AppKit - 类的重命名：如果当前系统是
iOS或者tvOS，那么将UIView重命名为ConstraintView，否则将NSView重命名为ConstraintView。其中typealias用于为已存在的类重新命名，提高代码的可读性。
总而言之，ConstraintView是为了适配多平台而定义的UIView或NSView的别称。
extension ConstraintView
紧接上文，view.snp是对ConstraintView的扩展，在ConstraintView+Extensions.swift中返回：
#if os(iOS) || os(tvOS)
import UIKit
#else
import AppKit
#endif
public extension ConstraintView {
// 此处略去很多废弃的方法
public var snp: ConstraintViewDSL {
return ConstraintViewDSL(view: self)
}
}
此处省略了该文件中很多被废弃的方法，只看最关键的变量snp，此处返回了一个新的对象ConstraintViewDSL，并以自己，一个ConstraintView作为参数。
注意：在SnapKit中，几乎所有文件开头都有关于导入UIKit还是AppKit的判断，之后就不再展示这段重复的代码。
ConstraintViewDSL
接下来jump到ConstraintViewDSL.swift文件中，这里只展示它的一个最关键方法：
public struct ConstraintViewDSL: ConstraintAttributesDSL {
public func makeConstraints(_ closure: (_ make: ConstraintMaker) -> Void) {
ConstraintMaker.makeConstraints(item: self.view, closure: closure)
}
internal let view: ConstraintView
internal init(view: ConstraintView) {
self.view = view
}
}
首先可以看到ConstraintViewDSL是一个结构体，实现了ConstraintAttributesDSL接口，构造函数也非常简单，只接收一个ConstraintView并保存起来；另外，view.snp.makeConstraints也只是把保存的ConstraintView，连同传递进来的闭包一起交给ConstraintMaker处理。
除了makeConstraints方法，还有remakeConstraints、updateConstraints、removeConstraints等方法，因为都是交给ConstraintMaker处理，所以不再赘述。
ConstraintMaker
ConstraintMaker.swift文件中：
public class ConstraintMaker {
private let item: LayoutConstraintItem
private var descriptions = [ConstraintDescription]()
internal init(item: LayoutConstraintItem) {
self.item = item
self.item.prepare()
}
internal static func prepareConstraints(item: LayoutConstraintItem, closure: (_ make: ConstraintMaker) -> Void) -> [Constraint] {
let maker = ConstraintMaker(item: item)
closure(maker)
var constraints: [Constraint] = []
for description in maker.descriptions {
guard let constraint = description.constraint else {
continue
}
constraints.append(constraint)
}
return constraints
}
internal static func makeConstraints(item: LayoutConstraintItem, closure: (_ make: ConstraintMaker) -> Void) {
let constraints = prepareConstraints(item: item, closure: closure)
for constraint in constraints {
constraint.activateIfNeeded(updatingExisting: false)
}
}
}
ConstraintMaker是一个类，从上面展示的代码可以知道创建约束的基本流程：首先makeConstraints调用prepareConstraints，构造一个maker，然后由闭包调用这个maker，遍历maker的descriptions，将获取的约束添加到一个约束数组constraints中，然后prepareConstraints执行完毕并将约束返回这个constraints，makeConstraints继续执行，获取这些约束，然后激活。
构造maker时，传入构造函数的item应为保存在ConstraintViewDSL中的ConstraintView，但在init声明中变成了LayoutConstraintItem？
LayoutConstraintItem
LayoutConstraintItem.swift：
public protocol LayoutConstraintItem: class {
}
extension ConstraintView : LayoutConstraintItem {
}
可以看到这是一个协议，并且ConstraintView实现了它，协议中也实现了一些方法，其中就包括prepare：
extension LayoutConstraintItem {
internal func prepare() {
if let view = self as? ConstraintView {
view.translatesAutoresizingMaskIntoConstraints = false
}
}
}
prepare方法禁用了从AutoresizingMask到Constraints的自动转换，即translatesAutoresizingMaskIntoConstraints可以把 frame ，bouds，center 方式布局的视图自动转化为约束形式，转化的结果就是自动添加需要的约束；而此时我们需要自己添加约束，必然会产生冲突，所以直接指定这个视图不去使用约束布局。
中途休息一下
到目前为止，我们知道了调用view.snp.makeConstraints时，这个view经过一系列转运，最终禁用了自己的约束布局，而这个过程仅仅是prepareConstraints方法的第一行，也就是只调用了ConstraintMaker的构造函数，接下来继续分析prepareConstraints。
internal static func prepareConstraints(item: LayoutConstraintItem, closure: (_ make: ConstraintMaker) -> Void) -> [Constraint] {
let maker = ConstraintMaker(item: item)
closure(maker)
var constraints: [Constraint] = []
for description in maker.descriptions {
guard let constraint = description.constraint else {
continue
}
constraints.append(constraint)
}
return constraints
}
构造maker之后，先是执行了闭包的内容（不在本文讨论范围内），紧接着创建了一个包含Constraint的数组constraints；然后遍历包含了ConstraintDescription类型的descriptions数组（该数组是maker成员变量，具体可以往上翻翻），并试图将每个description中包含的constraint添加到constraints数组中，最后返回该数组。
ConstraintDescription
ConstraintDescription.swift：
public class ConstraintDescription {
internal lazy var constraint: Constraint? = {
guard let relation = self.relation,
let related = self.related,
let sourceLocation = self.sourceLocation else {
return nil
}
let from = ConstraintItem(target: self.item, attributes: self.attributes)
return Constraint(
from: from,
to: related,
relation: relation,
sourceLocation: sourceLocation,
label: self.label,
multiplier: self.multiplier,
constant: self.constant,
priority: self.priority
)
}()
}
此处略去了很多成员变量，简单来说，ConstraintDescription内部持有一个Constraint变量，需要时可以利用自己的成员变量构造出一个Constraint并返回。
Constraint
Constraint.swift中，关键代码在构造函数，略去成员变量和方法，以及构造函数中关于多平台的适配之后，内容精简如下：
internal init(...) {
self.layoutConstraints = []
// get attributes
let layoutFromAttributes = self.from.attributes.layoutAttributes
let layoutToAttributes = self.to.attributes.layoutAttributes
// get layout from
let layoutFrom = self.from.layoutConstraintItem!
// get relation
let layoutRelation = self.relation.layoutRelation
for layoutFromAttribute in layoutFromAttributes {
// get layout to attribute
let layoutToAttribute: NSLayoutAttribute
if layoutToAttributes.count > 0 {
if self.from.attributes == .edges && self.to.attributes == .margins {
switch layoutFromAttribute {
case .left:
layoutToAttribute = .leftMargin
case .right:
layoutToAttribute = .rightMargin
case .top:
layoutToAttribute = .topMargin
case .bottom:
layoutToAttribute = .bottomMargin
default:
fatalError()
}
} else if self.from.attributes == .margins && self.to.attributes == .edges {
switch layoutFromAttribute {
case .leftMargin:
layoutToAttribute = .left
case .rightMargin:
layoutToAttribute = .right
case .topMargin:
layoutToAttribute = .top
case .bottomMargin:
layoutToAttribute = .bottom
default:
fatalError()
}
} else if self.from.attributes == self.to.attributes {
layoutToAttribute = layoutFromAttribute
} else {
layoutToAttribute = layoutToAttributes[0]
}
} else {
if self.to.target == nil && (layoutFromAttribute == .centerX || layoutFromAttribute == .centerY) {
layoutToAttribute = layoutFromAttribute == .centerX ? .left : .top
} else {
layoutToAttribute = layoutFromAttribute
}
}
// get layout constant
let layoutConstant: CGFloat = self.constant.constraintConstantTargetValueFor(layoutAttribute: layoutToAttribute)
// get layout to
var layoutTo: AnyObject? = self.to.target
// use superview if possible
if layoutTo == nil && layoutToAttribute != .width && layoutToAttribute != .height {
layoutTo = layoutFrom.superview
}
// create layout constraint
let layoutConstraint = LayoutConstraint(
item: layoutFrom,
attribute: layoutFromAttribute,
relatedBy: layoutRelation,
toItem: layoutTo,
attribute: layoutToAttribute,
multiplier: self.multiplier.constraintMultiplierTargetValue,
constant: layoutConstant
)
// set label
layoutConstraint.label = self.label
// set priority
layoutConstraint.priority = self.priority.constraintPriorityTargetValue
// set constraint
layoutConstraint.constraint = self
// append
self.layoutConstraints.append(layoutConstraint)
}
}
首先创建layoutConstraints来保存最后生成的所有LayoutConstraint（继承自NSLayoutConstraint），然后获取该约束的起始对象的约束属性layoutFromAttributes和目标对象的约束属性layoutToAttributes。接下来的主要逻辑就在循环体内，通过遍历起始对象的约束属性，然后获取目标对象的约束属性，最终创建一条新的约束。
至此，我们可以认为prepareConstraints执行完毕，makeConstraints已经获取到了所有需要的约束，接下来要执行最后一步：激活约束
activateIfNeeded
这是Constraint.swift中的一个方法：
internal func activateIfNeeded(updatingExisting: Bool = false) {
guard let item = self.from.layoutConstraintItem else {
print("WARNING: SnapKit failed to get from item from constraint. Activate will be a no-op.")
return
}
let layoutConstraints = self.layoutConstraints
if updatingExisting {
var existingLayoutConstraints: [LayoutConstraint] = []
for constraint in item.constraints {
existingLayoutConstraints += constraint.layoutConstraints
}
for layoutConstraint in layoutConstraints {
let existingLayoutConstraint = existingLayoutConstraints.first { $0 == layoutConstraint }
guard let updateLayoutConstraint = existingLayoutConstraint else {
fatalError("Updated constraint could not find existing matching constraint to update: \(layoutConstraint)")
}
let updateLayoutAttribute = (updateLayoutConstraint.secondAttribute == .notAnAttribute) ? updateLayoutConstraint.firstAttribute : updateLayoutConstraint.secondAttribute
updateLayoutConstraint.constant = self.constant.constraintConstantTargetValueFor(layoutAttribute: updateLayoutAttribute)
}
} else {
NSLayoutConstraint.activate(layoutConstraints)
item.add(constraints: [self])
}
}
这里首先获取了起始目标item，类型为LayoutConstraintItem，有变量constraintsSet来保存所有的约束；
然后获取了自己的layoutConstraints数组，Constraint不单指一个约束，而是layoutConstraints中所有约束的集合，或者说是snp.makeConstraints过程中的一个集合；
最后通过NSLayoutConstraint.activate激活了整个layoutConstraints数组中的约束，并且将这些约束添加到了起始目标的约束集合中保存起来。
