上一篇介绍了DTCoreText怎样把HTML+CSS解析转换成NSAttributeString，本篇接着看看怎样把NSAttributeString渲染出来。

CoreText

先简单介绍下CoreText，CoreText是iOS/OSX里的文字渲染引擎，在iOS/OSX上看到的所有文字在底层都是由CoreText去渲染。

CoreText会把一行里连在一起相同属性的文字合在一起作为一个CTRun，每一行是一个CTLine，多行合在一起组成CTFrame。如上图，第一行的文字有两种样式，第一部分是加粗，第二部分是斜体，因为样式不同所以分成了两个CTRun，CTLine包含了这两个CTRun，CTFrame包含了所有CTLine。

一个NSAttributeString可以通过CoreText提供的方法生成CTFramesetter，CTFramesetter是用于创建CTFrame的工厂，给CTFramesetter一个CGPath，或者简单理解为给他一个框框，它就会通过它持有的CTTypesetter生成CTFrame，CTFrame生成时里面包含的CTLine和CTRun就全部生成好了，可以直接绘制到画布上。CTFrame/CTLine/CTRun都提供了渲染接口，但前两者是封装，最后实际都是调用到CTRun的渲染接口去绘制。

如果要用CoreText渲染NSAttributeString，可以简单生成CTFramesetter，再生成CTFrame，在UIView的drawRect方法里直接把CTFrame绘制到当前画布上：

- (void) drawRect:(CGRect)rect
{
     UIBezierPath *path = [UIBezierPath bezierPathWithRect:CGRectMake(0, 0, 320, 400)];
     CTFramesetterRef framesetter = CTFramesetterCreateWithAttributedString((__bridge CFAttributedStringRef)content);
     CTFrame frame = CTFramesetterCreateFrame(framesetter,CFRangeMake(0, 0), [path CGPath] , NULL);
     CGContextRef ctx = UIGraphicsGetCurrentContext();
     CTFrameDraw(frame, ctx);
}

CoreText会按NSAttributeString里的样式属性把文字渲染出来。这种是最简单的粗粒度的渲染方式，但如果需要对文字渲染再做进一步处理，例如添加背景色等这些CoreText没有支持的属性，或者要在文字中间插入图片，就不能简单绘制CTFrame，需要逐行或逐个CTRun处理。

概览

DTCoreText需要处理穿插在文字里的各类Attachment，并支持文字背景色，段缩进等CoreText不支持的属性，不能简单把NSAttributeString扔给CoreText渲染了事，需要做更细致的处理。DTCoreText分了几层，整体结构图：

最上层是使用者，可以是Controller，例如项目里示例的DemoTextViewController，也可以是某视图类。接着是DTCoreText封装好的各个控件，自带的有Label，TextView和Cell，这些控件的文字渲染都由DTAttributedTextContentView负责，非文字部分例如图片/视频等元素会在上层使用者那里通过delegate传给DTAttributedTextContentView。DTCoreTextLayouter / DTCoreTextLayoutFrame / DTCoreTextLayoutLine / DTCoreTextGlyphRun这四个类分别对应CoreText里的CTFramesetter / CTFrame / CTLine / CTRun，模仿了CoreText的模式，功能和作用一样，只是在它们基础上添加了功能。接下来看看每一个类具体做了什么事情。

DTAttributedTextContentView

DTAttributedTextContentView继承自UIView，作为DTCoreTextLayoutFrame和上层控件的中间层，负责按需求绘制内容，大致做了以下几件事：

1.支持CATiledLayer分段渲染

把UIView的layerClass设为CATiledLayer就能实现分区域渲染，即只渲染显示在屏幕上的区域，类似那些地图APP的效果，主要用于像TextView这样可能内容很长的控件，避免一次性把全部内容渲染出来，只渲染能看到的部分，提高性能。使用CATiledLayer后，在-drawLayer:inContext:方法里用CGContextGetClipBoundingBox通过context取得当前显示的区域，DTCoreTextLayoutFrame只渲染这个区域的内容就行了。

2.生成DTCoreTextLayoutFrame并绘制

通过上层传进来的NSAttributeString生成DTCoreTextLayouter和DTCoreTextLayoutFrame，进行各种配置后用DTCoreTextLayoutFrame渲染文字到当前layer上，这些配置包括 是否显示图片链接/限定行数/断行规则等。

3.处理Attachment和Link

在-layoutSubviewsInRect:方法里遍历DTCoreTextLayoutFrame里的每一个DTCoreTextGlyphRun，找出有附件和链接的Run进行处理，附件包括图片/视频等，创建这些附件对应的view，把这些view按DTCoreTextGlyphRun计算好的位置添加到专门存放附件和链接的customViews上完事。

实际上这些附件view的创建是在上层使用者那里，DTAttributedTextContentView通过delegate把每个附件的内容和对应的frame传到上层生成相应的view再给回来，这样做估计是因为对附件的处理每个使用者的需求都不一样，不应该直接写死在底层，例如有些使用者要求图片需要点击后放大，视频需要用自己的控件等。

DTCoreTextLayouter

DTCoreTextLayouter负责生成和缓存DTCoreTextLayoutFrame，相当于CTFramesetter和CTFrame的关系，做的事很简单，就是通过NSAttributeString生成CTFramesetter，再根据不同的rect生成DTCoreTextLayoutFrame，并缓存这些frame。

DTCoreTextLayoutFrame

DTCoreTextLayoutFrame是最重要的一个类，负责渲染文字，主要做了两件事：生成行和渲染每一行。

生成DTCoreTextLayoutLine

-_buildLinesWithTypesetter:会创建出当前frame范围内可见的每一行DTCoreTextLayoutLine，创建过程中做的处理包括：

1.支持整段缩进

从NSAttributeString里取出当前行是否有表示缩进的DTTextBlock，如果需要缩进，要计算出当前行缩进后的宽度和位置。

2.支持截断加省略号

上层像Label/TextView这样的控件是限制了宽高的，如果内容超出了宽高，就需要对最后一行进行处理，在合适的位置加”…”。

这里有个问题，就是必须在渲染到超出宽高的那一行时，才知道要处理的最后一行是什么。例如一个TextView高40，文字每行高15，在渲染第三行时高已经到45，发现已经超出了TextView的高度，这时知道只能渲染到第二行，但当前已经处理到第三行了，需要把第二行拿出来截断加”…”。

另外除了超出高度，在超出外部传进来的numberOfLines时也要截断，为了统一流程，这里的做法是在渲染超出高度时记录总共可以渲染多少行(_numberLinesFitInFrame)，然后全部重新来，从头到尾再生成每一行，这时已经知道总共有多少行，在生成最后一行时处理就行了。这样做优点是简单粗暴避免重复代码，缺点是浪费性能，前面所有行都要重新排一遍。

3.支持hyphen

hyphen是连字符号，就是让英文单词在合适的位置换行并加上破折号”-“。CoreText原生不支持hyphen，断行方式只有按单词断行和安字母断行。这里hyphen的实现方式是：在所有英文单词里可以加破折号的位置全部加上占位符0x00AD，例如location->lo-ca-tion->lo0x00ADca0x00ADtion。0x00AD是不可见字符，CoreText不会渲染这个字符，但在这个字符的位置是可以断行的，CoreText不再认为location是一个单词，会在占位符处换行。DTCoreText做的处理就是如果发现换行处是占位符0x00AD，就替换成破折号”-“，所以要支持hyphen，传进来的内容就必须是所有单词都写好占位符的，否则无效。

4.计算每一行在当前frame的位置

在生成每一行时是不知道这一行在当前frame的位置的，需要自己手动计算。每一行的x坐标容易确定，但y坐标的计算就要费一番功夫。要考虑的因素有当前行高，上一行位置，行距，段间距，padding，baseline等。

如图，每一行以baseline为基准，需要计算出这一行的baseline在当前frame的Y坐标值，asent与descent是CoreText给出的值，asent+descent就是行高。推算当前行baseline位置的流程是：

• A.计算上一行的行末位置，即baseline+descent
• B.计算上一行行间距的一半，例如1.5倍行间距，就是 ((1.5 – 1)*asent+descent)/2
• C.计算当前行行间距的一半，算法同上，只是这一行的行间距不一定与上一行一致。这里两行各算一半也是为了不同行间距的中和。
• D.上述计算结果相加，再加上当前行asent值，就得到当前行的baseline Y坐标值。

除了上述主流程，还针对首行，段首段尾，DTTextBlock的留白和附件Attachment做了处理，计算的逻辑在-_algorithmWebKit_BaselineOriginToPositionLine。

5.处理对齐

要对每一种对齐方式进行处理，右对齐和居中对齐需要计算出行的x坐标值，两端对齐需要通过CTLineCreateJustifiedLine方法重新创建出一个两端对齐的行，针对两端对齐这里还要了两件事，一是段末不做两端对齐，二是若内容长度不够(默认是不足行宽的60%)也不做两端对齐，避免文字间距拉伸得太厉害效果差。

6.封装成DTCoreTextLayoutLine

经过上述处理，每一行的CTLine对象以及这一行的位置信息都有了，把这些封装成DTCoreTextLayoutLine保存起来，任务就完成了。

渲染

DTCoreTextLayoutFrame对外提供了-drawInContext:options:方法，用于把上述生成的每一行都渲染到传进来的context画布上。做的处理包括：

1.绘制DTTextBlock样式

DTCoreText支持段落加背景色，在这里会先找出所有DTTextBlock，通过一系列麻烦的方法取到这些block的坐标和大小，把它们对应的背景色画出来。

2.绘制附件

实现了DTTextAttachmentDrawing接口的附件可以在这里跟文字一起绘制出来，在DTCoreText里图片附件就是实现了DTTextAttachmentDrawing接口，可以直接把图片在这里绘制出来。实际上图片附件的渲染DTCoreText提供了两种方式，上面介绍DTAttributedTextContentView时说图片附件也可以在上层让用户自行添加，若要在上层自行添加，可以传参数告诉DTCoreTextLayoutFrame绘制时不要处理图片附件。

3.绘制文字和阴影

最后就是再遍历每一行DTCoreTextLayoutLine以及行里的每一个DTCoreTextGlyphRun，调用它的-drawInContext:方法逐个run绘制到画布上。绘制时需要算好每个Run的位置，调用CGContextSetTextPosition定位到指定位置绘制文字。绘制文字同时还处理了阴影效果，CoreText不直接支持文字阴影效果，但可以用CoreGraphic的接口在绘制时加上阴影，这里还支持同时存在多个shadow -_-!

DTCoreTextLayoutLine

DTCoreTextLayoutLine封装了CTLine，做的事包括：

1.生成GlyphRun

通过CTLine可以取出所这一行里的CTRun，计算每个CTRun的位置，封装生成DTCoreTextGlyphRun。

2.计算属性和提供辅助方法

计算并保存了这一行asent/descent/lineHeight等属性，提供各种辅助方法方便获取这一行里的信息，包括通过stringIndex获取对应文字的坐标等，CTLine相关的几个方法例如CTLineGetOffsetForStringIndex() / CTLineGetStringIndexForPosition()也有相应的封装。

DTCoreTextGlyphRun

DTCoreTextGlyphRun里做的事跟DTCoreTextLayoutLine差不多，只是在渲染方法里额外做了一些事，首先支持文字背景色，这是CoreText原生不支持的，如果Attribute里有背景色的属性，这里会绘制出来。然后支持iOS6以下文字的下划线和删除线，iOS6以前CoreText是不支持下划线和删除线的，这里自己做了处理把它画上去。

总结

整个流程最核心的就是DTCoreTextLayoutFrame生成行和渲染的实现，相当于把CoreText原生的CTFramesetterCreateFrame / CTFrameDraw再自己实现了一遍，在实现的过程加上自己特殊的需求，从中我们也可以大致了解到CTFrame/CTLine内部大致实现是怎样的。CoreText已经提供了足够细粒度的接口让使用者可以按自己意愿去随意排版，DTCoreText这一系列的处理给出了很好的示例可供参考。

React Native是facebook刚开源的框架，可以用javascript直接开发原生APP，先不说这个框架后续是否能得到大众认可，单从源码来说，这个框架源码里有非常多的设计思想和实现方式值得mg游戏平台官方网站，本篇先来看看它最基础的JavaScript-ObjectC通信机制(以下简称JS/OC)。

概览

React Native用iOS自带的JavaScriptCore作为JS的解析引擎，但并没有用到JavaScriptCore提供的一些可以让JS与OC互调的特性，而是自己实现了一套机制，这套机制可以通用于所有JS引擎上，在没有JavaScriptCore的情况下也可以用webview代替，实际上项目里就已经有了用webview作为解析引擎的实现，应该是用于兼容iOS7以下没有JavascriptCore的版本。

普通的JS-OC通信实际上很简单，OC向JS传信息有现成的接口，像webview提供的-stringByEvaluatingJavaScriptFromString方法可以直接在当前context上执行一段JS脚本，并且可以获取执行后的返回值，这个返回值就相当于JS向OC传递信息。React Native也是以此为基础，通过各种手段，实现了在OC定义一个模块方法，JS可以直接调用这个模块方法并还可以无缝衔接回调。

举个例子，OC定义了一个模块RCTSQLManager，里面有个方法-query:successCallback:，JS可以直接调用RCTSQLManager.query并通过回调获取执行结果。：

//OC:
@implement RCTSQLManager
- (void)query:(NSString *)queryData successCallback:(RCTResponseSenderBlOCk)responseSender
{
     RCT_EXPORT();
     NSString *ret = @"ret"
     responseSender(ret);
}
@end

//JS:
RCTSQLManager.query("SELECT * FROM table", function(result) {
     //result == "ret";
});

接下来看看它是怎样实现的。

模块配置表

首先OC要告诉JS它有什么模块，模块里有什么方法，JS才知道有这些方法后才有可能去调用这些方法。这里的实现是OC生成一份模块配置表传给JS，配置表里包括了所有模块和模块里方法的信息。例：

{
    "remoteModuleConfig": {
        "RCTSQLManager": {
            "methods": {
                "query": {
                    "type": "remote",
                    "methodID": 0
                }
            },
            "moduleID": 4
        },
        ...
     },
}

OC端和JS端分别各有一个bridge，两个bridge都保存了同样一份模块配置表，JS调用OC模块方法时，通过bridge里的配置表把模块方法转为模块ID和方法ID传给OC，OC通过bridge的模块配置表找到对应的方法执行之，以上述代码为例，流程大概是这样（先不考虑callback）：

在了解这个调用流程之前，我们先来看看OC的模块配置表式怎么来的。我们在新建一个OC模块时，JS和OC都不需要为新的模块手动去某个地方添加一些配置，模块配置表是自动生成的，只要项目里有一个模块，就会把这个模块加到配置表上，那这个模块配置表是怎样自动生成的呢？分两个步骤：

1.取所有模块类

每个模块类都实现了RCTBridgeModule接口，可以通过runtime接口objc_getClassList或objc_copyClassList取出项目里所有类，然后逐个判断是否实现了RCTBridgeModule接口，就可以找到所有模块类，实现在RCTBridgeModuleClassesByModuleID()方法里。

2.取模块里暴露给JS的方法

一个模块里可以有很多方法，一些是可以暴露给JS直接调用的，一些是私有的不想暴露给JS，怎样做到提取这些暴露的方法呢？我能想到的方法是对要暴露的方法名制定一些规则，比如用RCTExport_作为前缀，然后用runtime方法class_getInstanceMethod取出所有方法名字，提取以RCTExport_为前缀的方法，但这样做恶心的地方是每个方法必须加前缀。React Native用了另一种黑魔法似的方法解决这个问题：编译属性__attribute__。

在上述例子中我们看到模块方法里有句代码：RCT_EXPORT()，模块里的方法加上这个宏就可以实现暴露给JS，无需其他规则，那这个宏做了什么呢？来看看它的定义：

#define RCT_EXPORT(JS_name) __attribute__((used, section("__DATA,RCTExport" \
))) static const char *__rct_export_entry__[] = { __func__, #JS_name }

这个宏的作用是用编译属性__attribute__给二进制文件新建一个section，属于__DATA数据段，名字为RCTExport，并在这个段里加入当前方法名。编译器在编译时会找到__attribute__进行处理，为生成的可执行文件加入相应的内容。效果可以从linkmap看出来：

# Sections:
# Address Size Segment Section
0x100001670 0x000C0180 __TEXT __text
...
0x10011EFA0 0x00000330 __DATA RCTExport
0x10011F2D0 0x00000010 __DATA __common
0x10011F2E0 0x000003B8 __DATA __bss
...
0x10011EFA0 0x00000010 [ 4] -[RCTStatusBarManager setStyle:animated:].__rct_export_entry__
0x10011EFB0 0x00000010 [ 4] -[RCTStatusBarManager setHidden:withAnimation:].__rct_export_entry__
0x10011EFC0 0x00000010 [ 5] -[RCTSourceCode getScriptText:failureCallback:].__rct_export_entry__
0x10011EFD0 0x00000010 [ 7] -[RCTAlertManager alertWithArgs:callback:].__rct_export_entry__
...

可以看到可执行文件数据段多了个RCTExport段，内容就是各个要暴露给JS的方法。这些内容是可以在运行时获取到的，在RCTBridge.m的RCTExportedMethodsByModuleID()方法里获取这些内容，提取每个方法的类名和方法名，就完成了提取模块里暴露给JS方法的工作。

整体的模块类/方法提取实现在RCTRemoteModulesConfig()方法里。

调用流程

接下来看看JS调用OC模块方法的详细流程，包括callback回调。这时需要细化一下上述的调用流程图：

看起来有点复杂，不过一步步说明，应该很容易弄清楚整个流程，图中每个流程都标了序号，从发起调用到执行回调总共有11个步骤，详细说明下这些步骤：

1.JS端调用某个OC模块暴露出来的方法。

2.把上一步的调用分解为ModuleName,MethodName,arguments，再扔给MessageQueue处理。

3.在这一步把JS的callback函数缓存在MessageQueue的一个成员变量里，用CallbackID代表callback。在通过保存在MessageQueue的模块配置表把上一步传进来的ModuleName和MethodName转为ModuleID和MethodID。

4.把上述步骤得到的ModuleID,MethodId,CallbackID和其他参数argus传给OC。至于具体是怎么传的，后面再说。

5.OC接收到消息，通过模块配置表拿到对应的模块和方法。

6.RCTModuleMethod对JS传过来的每一个参数进行处理。

7.OC模块方法调用完，执行block回调。

8.调用到第6步说明的RCTModuleMethod生成的block。

9.block里带着CallbackID和block传过来的参数去调JS里MessageQueue的方法invokeCallbackAndReturnFlushedQueue。

10.MessageQueue通过CallbackID找到相应的JS callback方法。

11.调用callback方法，并把OC带过来的参数一起传过去，完成回调。

整个流程就是这样，简单概括下，差不多就是：JS函数调用转ModuleID/MethodID -> callback转CallbackID -> OC根据ID拿到方法 -> 处理参数 -> 调用OC方法 -> 回调CallbackID -> JS通过CallbackID拿到callback执行

事件响应

上述第4步留下一个问题，JS是怎样把数据传给OC，让OC去调相应方法的？

答案是通过返回值。JS不会主动传递数据给OC，在调OC方法时，会在上述第4步把ModuleID,MethodID等数据加到一个队列里，等OC过来调JS的任意方法时，再把这个队列返回给OC，此时OC再执行这个队列里要调用的方法。

一开始不明白，设计成JS无法直接调用OC，需要在OC去调JS时才通过返回值触发调用，整个程序还能跑得通吗。后来想想纯native开发里的事件响应机制，就有点理解了。native开发里，什么时候会执行代码？只在有事件触发的时候，这个事件可以是启动事件，触摸事件，timer事件，系统事件，回调事件。而在React Native里，这些事件发生时OC都会调用JS相应的模块方法去处理，处理完这些事件后再执行JS想让OC执行的方法，而没有事件发生的时候，是不会执行任何代码的，这跟native开发里事件响应机制是一致的。

说到OC调用JS，再补充一下，实际上模块配置表除了有上述OC的模块remoteModules外，还保存了JS模块localModules，OC调JS某些模块的方法时，也是通过传递ModuleID和MethodID去调用的，都会走到-enqueueJSCall:args:方法把两个ID和参数传给JS的BatchedBridge.callFunctionReturnFlushedQueue，跟JS调OC原理差不多，就不再赘述了。

总结

整个React Native的JS-OC通信机制大致就是这样了，关键点在于：模块化，模块配置表，传递ID，封装调用，事件响应，其设计思想和实现方法很值得mg游戏平台官方网站借鉴。

DTCoreText是个开源的iOS富文本组件，它可以解析HTML与CSS最终用CoreText绘制出来，通常用于在一些需要显示富文本的场景下代替低性能的UIWebView，来看看它是怎样解析和渲染HTML+CSS的，总体上分成两步：

1. 数据解析—把HTML+CSS转换成NSAttributeString
2. 渲染—用CoreText把NSAttributeString内容渲染出来，再加上图片等元素

本篇先介绍第一步，数据解析的实现。

概览

整体流程如图，HTML字符串传入DTHTMLAttributeStringBuilder，通过DTHTMLParser的回调解析后生成dom树，dom树的每个节点都是自定义的DTHTMLElement，通过DTCSSStylesheet解析每个元素对应的样式，这时每个DTHTMLElement已经包含了节点的内容和样式，最后从DTHTMLElement生成NSAttributeString。这一切都是在解析dom的过程中同步进行，为了分析方便，我们还是把它分为三个步骤：

1. 解析HTML，生成dom树
2. 解析CSS，合并得到每个dom节点对应的样式
3. 生成NSAttributeString

接下来详细介绍这三个步骤的实现方式。

解析HTML

iOS/OSX自带了XML/HTML的解析引擎libxml，它提供了两种解析html的接口：

1. DOM解析

直接根据HTML字符串在内存生成一颗dom树，使用者可以自由遍历这颗dom树。这个方法的优点是使用简单方便，缺点一是内存使用多，无论多大的html文件都会一次性生成dom树放在内存里，二是性能不高，它生成dom树时遍历了一遍，用户使用时又遍历了一遍。

2. SAX解析

SAX的解析方式不会返回一个dom树，而是把解析过程都暴露给使用者，通过回调函数告诉调用者当前解析到了什么元素/内容，让使用者决定怎么处理。举个例子，对<p>content</p>这段html进行解析时，解析器找到<p>标签就会回调startElement方法，告诉使用者找到了一个标签的开始标志，tag是p。接着解析到content，会回调_characters，告诉使用者解析到文本内容，最后解析</p>回调endElement，告诉调用者遇到标签结束标志。

这种解析方式的优点一是占用内存少，它的解析是流式的，不需要一次性传入整个内容，也不生成占内存的dom树，二是性能高，相当于使用时边解析边处理，而不是解析完生成dom树后再遍历dom树进行处理，少了一步。缺点是使用复杂。

DTCoreText采用的是SAX解析方式，主要原因应该还是为了性能考虑。DTHTMLParser把libxml这种解析方式的c接口封装成OC接口，用delegate的方式通知回调用者各个解析事件，除此之外还做了几件事：

1. 处理文本编码
2. 转换数据格式，把dom节点的attribute转成NSDictionary，error换成NSError，bytes换成NSData。
3. 因为libxml一次只解析一小部分字符串，如果dom的内容特别长，libxml会分多次回调_characters，DTHTMLParser做了数据拼合的工作，确保回调给delegate的内容数据是完整的。

DTHTMLAttributeStringBuilder接收DTHTMLParser的回调，生成dom树，节点是自定义的DTHTMLElement，有指向父节点的引用以及子节点数组，生成dom树的实现逻辑很简单：

1. 实例变量_currentTag用于保存当正在解析的节点（回调了startElement未回调endElement的节点）。
2. startElement回调时，假设当前回调里找到的节点是elem，把elem设为_currentTag的子节点，再把_currentTag变量设为elem。
3. 找到文本内容foundCharacters回调时，内容作为一个节点，设为_currentTag的子节点。
4. endElement回调时，_currentTag变量设为_currentTag的父节点。

简化代码：

- (void)startElement:(NSString *)elemName
{
     Element *elem = [Element elementWithName:elemName];
     if (_currentTag) {
          [_currentTag.childNodes addObject:elem];
          elem.parentNode = _currentTag;
     }
     _currentTag = elem;
}
- (void)foundCharacters:(NSString *)ctn
{
     Element *elem = [[Element alloc] initWithString:ctn];
     [_currentTag.childNodes addObject:elem];
     elem.parentNode = _currentTag;
}
- (void)endElement:(NSString *)elemName
{
     _currentTag = _currentTag.parentNode;
}

这套逻辑循环下来，就生成了dom树。

其他细节

1. 不同的DTHTMLElement子类。

在生成dom树节点时，DTHTMLElement会根据传入的标签名生成不同的子类，包括文本DTTextHTMLElement，超链接DTAnchorHTMLElement，列表DTListItemHTMLElement等，这些子类实现了各自特殊的样式和转换成NSAttributeString的逻辑，后面会提到。

2. 特殊标签逻辑

DTHTMLAttributedStringBuilder在回调startElement和endElement里会对不同标签做一些特殊处理，例如<style>标签要解析里面的css内容，<link>标签要读取文件再解析css内容，<h1>标签要设置元素的headerLevel等。可能为了代码好看些，这些处理逻辑是放_tagStartHandlers/_tagEndHandlers这两个dictionary，key是标签名，value是处理的block，startElement/endElement时根据元素名调用相应的block。

3. 多线程解析

为了解析的速度更快，DTHTMLAttributedStringBuilder生成了三个dispatch_queue，分别是
解析html的_dataParsingQueue，生成dom树的_treeBuildingQueue，以及组装NSAttributeString的_stringAssemblyQueue，把解析过程有序地分派到这三条线程里并行执行，并用dispatch_group_wait阻塞等到所有任务都完成时同步返回结果。

解析CSS

对样式CSS的解析大致流程是这样：css原数据->结构化NSDictionary->合并样式->DTHTMLElement属性。最终为每一个DTHTMLElement解析出这个元素的最终样式，接下来看看每一步是怎么做的。

1.结构化

css文本最终需要变成结构化的NSDictionary，便于为dom节点匹配选择器和处理，例如：

body {
    font-size:14px;
    background: #fff;
}
.hd {
    width:100px;
}

最终要转变成

@{
    @“body”: @{
        @“font-size”: @“14px”,        @“background”: @“#fff”
    },
    @“.hd”: @{@“width”: @“100px”},
}

css数据的解析比较简单，不需要词法分析，只需要字符串匹配，分两步走：

- (void)parseStyleBlock:(NSString *)css
{
     int braceMarker = 0;
     NSString* selector;
     for (int i = 0; i < css.length; i ++) {
          if (c == ‘{‘) {
               selector = [ css substringWithRange:NSMakeRange(braceMarker, i-braceMarker)];
               braceMarker = i + 1;
          }
          if (c == ‘}‘) {
               NSString *rule = [ css substringWithRange:NSMakeRange(braceMarker, i-braceMarker)];
               [self addRule:rule withSelector:selector];
               braceMarker = i + 1;
          }
     }
}

2.合并样式

影响一个dom节点css样式的内容分布在四个地方，一是全局默认样式，二是HTML里<link>标签外联的css文件，三是HTML里<style>标签里的内容，四是dom节点style属性(例<a style=“color:white”>)。

DTHTMLAttributeStringBuilder持有一个_globalStyleSheet，在初始化时就加载并解析了全局默认样式。接着在解析HTML生成dom树的过程中，如果遇到<style>标签，会对标签里的css内容进行解析，然后合并入_globalStyleSheet，<link>标签也一样，会根据文件路径读取css文件内容并解析合并，自此上述前三个点都合并在_globalStyleSheet里了。接着要解析一个dom节点的样式时，调用_globalStyleSheet的mergedStyleDictionaryForElement:方法，把节点传进来，用节点的tagName/class/id等属性在_globalStyleSheet表里匹配到相应的css样式，接着解析节点自身的style属性合并，就得到了这个节点里所有的css样式。

3.转化为DTHTMLElement属性

DTHTMLElement的applyStyleDictionary:方法会把css属性转换为DTHTMLElement自身的属性，方法就是一个个属性去处理了，十分繁琐。

影响一个dom节点样式的其实还有两个点，一是dom里某些属性(例<p align=“left”>)，二是从父节点继承下来的样式。分别在DTHTMLElement的两个方法inheritAttributesFromElement:和interpretAttribute里处理了，从父节点继承下来的不是css样式，而是处理好的DTHTMLElement属性。因为解析HTML是顺序解析，在解析子节点时父节点的样式一定已经解析完成，所以可以直接从父节点继承解析好的DTHTMLElement属性。这两点都是直接操作DTHTMLElement属性，不涉及CSS。

其他细节

1. 派生选择器

DTCSSStylesheet的选择器是支持派生选择器的，类似li a{}，只匹配在<li>节点下的<a>节点，其他<a>不匹配。实现方式跟浏览器实现原理一样，拿到要匹配的DTHTMLElement节点，先把_globalStyleSheet里的所有派生选择器找出来，从右开始匹配，匹配到就遍历元素的父节点看是否匹配左边的选择器。例如li a{}，先看节点是否<a>，若是，遍历节点的父节点，若找到有一个父节点是<li>，则匹配成功，否则匹配不成功，继续寻找下一个。具体实现在matchingComplexCascadingSelectorsForElement:方法里。

2. 选择器权重

DTCSSStylesheet的选择器是有权重的，内联样式>id选择器>class选择器>派生选择器>tag选择器，权重高的会覆盖权重低的样式，若权重相等，则按书写的位置排，位置在后面的覆盖前面的。DTCSSStylesheet给每个selector定了权重值，id为100，class为10，其他为1，派生选择器的权重为各个selector类型权重的相加，在解析css时把选择器的权重和出现的顺序都保存起来，匹配时按权重和顺序值决定覆盖的规则。

3. 缩写

一些css属性是有缩写的方式的，例如font:10px  bold;就包括了font-size和font-weight，margin:10px 0;就包括了margin的四个方向，在对一个DTHTMLElement寻找匹配属性时，会把这些这些缩写全部处理展开，方便DTHTMLElement再进一步处理。处理的实现在_uncompressShorthands:里。

自此dom树上每个节点以及它们的样式都解析完成，只差最后一步转为NSAttributeString。

生成NSAttributeString

经过上述两大步骤后，dom树上的各DTHTMLElement节点都保存了各自完整的内容和样式，每个DTHTMLElement都可以完整地转换成NSAttributeString然后进行渲染。DTHTMLElement有个attributedString方法，负责生成对应的NSAttributeString，实现方式是把所有子节点的attributedString拼起来返回，递归调用直到叶子节点。

叶子节点有多种类型，包括文本DTTextHTMLElement，超链接DTAnchorHTMLElement，列表DTListItemHTMLElement等，它们都会根据attributesForAttributedStringRepresentation方法把DTHTMLElement的属性转化为CoreText认得的样式表，应用在自身内容上，生成NSAttributeString返回。只有叶子节点才会真正生成NSAttributeString内容，其他节点只会把所有子节点的内容拼起来。简化代码：

//普通节点：
- (NSAttributeString *)attributedString
{
  NSMutableAttributedString *tmpString = [[NSMutableAttributedString alloc] init];
  for (Element *elem in self.childNodes) {
    [tmpString appendString:[elem attributedString]];
  }
  return tmpString;
}
//叶子节点(文本内容节点DTTextHTMLElement为例)：
- (NSAttributeString *)attributedString
{
  NSDictionary *attributes = [self attributesForAttributedStringRepresentation];
  return [[NSAttributedString alloc] initWithString:_text attributes:attributes];
}

因为调用一个DTHTMLElement的attributedString方法就可以得到它所有子节点拼合的NSAttributeString，所以只要调用body节点的attributeString，就可以获得最终的NSAttributeString。但是很多时候使用者传进来的只是一个html片段而不是一个完整的页面，很可能没有body节点，DTHTMLAttributeStringBuilder里处理了这种情况，不直接使用body的attributedString，body节点/没有父节点的节点/父节点是body的节点都会调用一次attributedString方法生成NSAttributeString，在DTHTMLAttributeStringBuilder里拼合成最终结果。

多媒体

Coretext只能渲染文字，那多媒体元素像图片/视频等是怎样渲染的？首先在多媒体出现的地方，会在NSAttributeString里插入一个占位符，这个占位符的attribute属性里包含了多媒体对象，渲染到这个占位符时我们可以取出attribute里的多媒体对象，再通过addSubView之类的方式渲染上去。在我们渲染多媒体对象前还需要让CoreText知道这个多媒体占多大空间，让CoreText渲染文字时留出空白，实现方式是在占位符的attribute里加上kCTRunDelegateAttributeName，CoreText在渲染时会先回调attribute上这个键对应的callback，在callback里通过多媒体对象告诉CoreText需要留多大空位就行了。

其他细节

1. display=none的节点不输出NSAttributeString。
2. display=block的节点(例如<p><div><h1>)，会在内容后再加个换行符，根据css规则，后面的元素不能跟它同行，除非是float，目前不支持float属性。
3. 上一个元素是display=inline(例如<a><strong><span>)，当前元素是display=block时，需要在内容前面添加换行。inline是不换行的，block又要要单独一行，所以需要做这个判断。
4. dom节点上的一些属性也会加入NSAttributeString的attribute。

最终成果

<html>
    <style>
        .fl {
            font:15px;
        }
        .fl strong {
            color:red;
        }
    </style>
    <body>
        <h1>第六章</h1>
        <p class="fl">我将来要当一名麦田里的守望者。有那么一群孩子在一大块麦田里玩。<strong>几千几万的小孩子</strong>，附近没有一个大人，我是说—除了我。我呢。就在那混帐的悬崖边。我的职务就是在那守望。要是有哪个孩子往悬崖边来，我就把他捉住—我是说孩子们都是在狂奔，也不知道自己是在往哪儿跑。我得从什么地方出来，把他们捉住。我整天就干这样的事，我只想做个麦田里的守望者。</p>
        <p><img src="./catcher.png" /></p>
    </body>
</html>

这个html经过这三步转换，变成了以下NSAttributeString:

第六章
{CTForegroundColor = "<CGColor 0x7fcf22d17a00>...";DTHeaderLevel = 1;NSFont = "<UICTFont: 0x7fcf25050ed0> font-family: \"Times New Roman\"; font-weight: normal; font-style: normal; font-size: 12.00pt";NSParagraphStyle = "<CTParagraphStyle: 0x7fcf22d18ca0>{...}";
}
我将来要当一名麦田里的守望者。有那么一群孩子在一大块麦田里玩。
{CTForegroundColor = "<CGColor 0x7fcf22d17a00>...";NSFont = "<UICTFont: 0x7fcf25050ed0> font-family: \"Times New Roman\"; font-weight: normal; font-style: normal; font-size: 12.00pt";NSParagraphStyle = "<CTParagraphStyle: 0x7fcf2504e5f0>{...}";}
几千几万的小孩子
{CTForegroundColor = "<CGColor 0x7fcf22d17a00>...";NSFont = "<UICTFont: 0x7fcf25050ed0> font-family: \"Times New Roman\"; font-weight: normal; font-style: normal; font-size: 12.00pt";NSParagraphStyle = "<CTParagraphStyle: 0x7fcf22d2e530>{...}";}
，附近没有一个大人，我是说—除了我。我呢。就在那混帐的悬崖边。我的职务就是在那守望。要是有哪个孩子往悬崖边来，我就把他捉住—我是说孩子们都是在狂奔，也不知道自己是在往哪儿跑。我得从什么地方出来，把他们捉住。我整天就干这样的事，我只想做个麦田里的守望者。{CTForegroundColor = "<CGColor 0x7fcf22d17a00>...";NSFont = "<UICTFont: 0x7fcf25050ed0> font-family: \"Times New Roman\"; font-weight: normal; font-style: normal; font-size: 12.00pt";NSParagraphStyle = "<CTParagraphStyle: 0x7fcf2504e5f0>{...}";}

{CTForegroundColor = "<CGColor 0x7fcf22d17a00>...";CTRunDelegate = "<CTRunDelegate 0x7fcf22d18400 [0x103d7cef0]>";DTAttachmentParagraphSpacing = 0;
NSAttachmentAttributeName = "<DTImageTextAttachment: 0x7fcf22d241b0>";NSFont = "<UICTFont: 0x7fcf25050ed0> font-family: \"Times New Roman\"; font-weight: normal; font-style: normal; font-size: 12.00pt";NSParagraphStyle = "<CTParagraphStyle: 0x7fcf25044470>{...}";

接下来就可以拿这个NSAttributeString用CoreText渲染了。

FastImageCache是Path团队开发的一个开源库，用于提升图片的加载和渲染速度，让基于图片的列表滑动起来更顺畅，来看看它是怎么做的。

优化点

iOS从磁盘加载一张图片，使用UIImageVIew显示在屏幕上，需要经过以下步骤：

1. 从磁盘拷贝数据到内核缓冲区
2. 从内核缓冲区复制数据到用户空间
3. 生成UIImageView，把图像数据赋值给UIImageView
4. 如果图像数据为未解码的PNG/JPG，解码为位图数据
5. CATransaction捕获到UIImageView layer树的变化
6. 主线程Runloop提交CATransaction，开始进行图像渲染
   • 6.1 如果数据没有字节对齐，Core Animation会再拷贝一份数据，进行字节对齐。
   • 6.2 GPU处理位图数据，进行渲染。

FastImageCache分别优化了2,4,6.1三个步骤：

1. 使用mmap内存映射，省去了上述第2步数据从内核空间拷贝到用户空间的操作。
2. 缓存解码后的位图数据到磁盘，下次从磁盘读取时省去第4步解码的操作。
3. 生成字节对齐的数据，防止上述第6.1步CoreAnimation在渲染时再拷贝一份数据。

接下来具体介绍这三个优化点以及它的实现。

内存映射

平常我们读取磁盘上的一个文件，上层API调用到最后会使用系统方法read()读取数据，内核把磁盘数据读入内核缓冲区，用户再从内核缓冲区读取数据复制到用户内存空间，这里有一次内存拷贝的时间消耗，并且读取后整个文件数据就已经存在于用户内存中，占用了进程的内存空间。

FastImageCache采用了另一种读写文件的方法，就是用mmap把文件映射到用户空间里的虚拟内存，文件中的位置在虚拟内存中有了对应的地址，可以像操作内存一样操作这个文件，相当于已经把整个文件放入内存，但在真正使用到这些数据前却不会消耗物理内存，也不会有读写磁盘的操作，只有真正使用这些数据时，也就是图像准备渲染在屏幕上时，虚拟内存管理系统VMS才根据缺页加载的机制从磁盘加载对应的数据块到物理内存，再进行渲染。这样的文件读写文件方式少了数据从内核缓存到用户空间的拷贝，效率很高。

解码图像

一般我们使用的图像是JPG/PNG，这些图像数据不是位图，而是是经过编码压缩后的数据，使用它渲染到屏幕之前需要进行解码转成位图数据，这个解码操作是比较耗时的，并且没有GPU硬解码，只能通过CPU，iOS默认会在主线程对图像进行解码。很多库都解决了图像解码的问题，不过由于解码后的图像太大，一般不会缓存到磁盘，SDWebImage的做法是把解码操作从主线程移到子线程，让耗时的解码操作不占用主线程的时间。

FastImageCache也是在子线程解码图像，不同的是它会缓存解码后的图像到磁盘。因为解码后的图像体积很大，FastImageCache对这些图像数据做了系列缓存管理，详见下文实现部分。另外缓存的图像体积大也是使用内存映射读取文件的原因，小文件使用内存映射无优势，内存拷贝的量少，拷贝后占用用户内存也不高，文件越大内存映射优势越大。

字节对齐

Core Animation在图像数据非字节对齐的情况下渲染前会先拷贝一份图像数据，官方文档没有对这次拷贝行为作说明，模拟器和Instrument里有高亮显示“copied images”的功能，但似乎它有bug，即使某张图片没有被高亮显示出渲染时被copy，从调用堆栈上也还是能看到调用了CA::Render::copy_image方法：

那什么是字节对齐呢，按我的理解，为了性能，底层渲染图像时不是一个像素一个像素渲染，而是一块一块渲染，数据是一块块地取，就可能遇到这一块连续的内存数据里结尾的数据不是图像的内容，是内存里其他的数据，可能越界读取导致一些奇怪的东西混入，所以在渲染之前CoreAnimation要把数据拷贝一份进行处理，确保每一块都是图像数据，对于不足一块的数据置空。大致图示：(pixel是图像像素数据，data是内存里其他数据)

块的大小应该是跟CPU cache line有关，ARMv7是32byte，A9是64byte，在A9下CoreAnimation应该是按64byte作为一块数据去读取和渲染，让图像数据对齐64byte就可以避免CoreAnimation再拷贝一份数据进行修补。FastImageCache做的字节对齐就是这个事情。

实现

FastImageCache把同个类型和尺寸的图像都放在一个文件里，根据文件偏移取单张图片，类似web的css雪碧图，这里称为ImageTable。这样做主要是为了方便统一管理图片缓存，控制缓存的大小，整个FastImageCache就是在管理一个个ImageTable的数据。整体实现的数据结构如图：

一些补充和说明：

ImageTable

1. 一个ImageFormat对应一个ImageTable，ImageFormat指定了ImageTable里图像渲染格式/大小等信息，ImageTable里的图像数据都由ImageFormat规定了统一的尺寸，每张图像大小都是一样的。
2. 一个ImageTable一个实体文件，并有另一个文件保存这个ImageTable的meta信息。
3. 图像使用entityUUID作为唯一标示符，由用户定义，通常是图像url的hash值。ImageTable Meta的indexMap记录了entityUUID->entryIndex的映射，通过indexMap就可以用图像的entityUUID找到缓存数据在ImageTable对应的位置。

ImageTableEntry

1. ImageTable的实体数据是ImageTableEntry，每个entry有两部分数据，一部分是对齐后的图像数据，另一部分是meta信息，meta保存这张图像的UUID和原图UUID，用于校验图像数据的正确性。
2. Entry数据是按内存分页大小对齐的，数据大小是内存分页大小的整数倍，这样可以保证虚拟内存缺页加载时使用最少的内存页加载一张图像。
3. 图像数据做了字节对齐处理，CoreAnimation使用时无需再处理拷贝。具体做法是CGBitmapContextCreate创建位图画布时bytesPerRow参数传64倍数。

Chunk

• ImageTable和实体数据Entry间多了层Chunk，Chunk是逻辑上的数据划分，N个Entry作为一个Chunk，内存映射mmap操作是以chunk为单位的，每一个chunk执行一次mmap把这个chunk的内容映射到虚拟内存。为什么要多一层chunk呢，按我的理解，这样做是为了灵活控制mmap的大小和调用次数，若对整个ImageTable执行mmap，载入虚拟内存的文件过大，若对每个Entry做mmap，调用次数会太多。

缓存管理

• 用户可以定义整个ImageTable里最大缓存的图像数量，在有新图像需要缓存时，如果缓存没有超过限制，会以chunk为单位扩展文件大小，顺序写下去。如果已超过最大缓存限制，会把最少使用的缓存替换掉，实现方法是每次使用图像都会把UUID插入到MRUEntries数组的开头，MRUEntries按最近使用顺序排列了图像UUID，数组里最后一个图像就是最少使用的。被替换掉的图片下次需要再使用时，再走一次取原图—解压—存储的流程。

使用

FastImageCache适合用于tableView里缓存每个cell上同样规格的图像，优点是能极大加快第一次从磁盘加载这些图像的速度。但它有两个明显的缺点：一是占空间大。因为缓存了解码后的位图到磁盘，位图是很大的，宽高100*100的图像在2x的高清屏设备下就需要200*200*4byte/pixel=156KB，这也是为什么FastImageCache要大费周章限制缓存大小。二是接口不友好，需预定义好缓存的图像尺寸。FastImageCache无法像SDWebImage那样无缝接入UIImageView，使用它需要配置ImageTable，定义好尺寸，手动提供的原图，每种实体图像要定义一个FICEntity模型，使逻辑变复杂。

FastImageCache已经属于极限优化，做图像加载/渲染优化时应该优先考虑一些低代价高回报的优化点，例如CALayer代替UIImageVIew，减少GPU计算（去透明/像素对齐），图像子线程解码，避免Offscreen-Render等。在其他优化都做到位，图像的渲染还是有性能问题的前提下才考虑使用FastImageCache进一步提升首次加载的性能，不过字节对齐的优化倒是可以脱离FastImageCache直接运用在项目上，只需要在解码图像时bitmap画布的bytesPerRow设为64的倍数即可。

续AFNetworking2.0源码解析<一><二><三>，本篇来看看AFURLResponseSerialization做的事情。

结构

AFURLResponseSerialization负责解析网络返回数据，检查数据是否合法，把NSData数据转成相应的对象，内置的转换器有json,xml,plist,image，用户可以很方便地继承基类AFHTTPResponseSerializer去解析更多的数据格式，AFNetworking这一套响应解析机制结构很简单，主要就是两个方法：

1.-validateResponse:data:error:

基类AFHTTPResponseSerializer的这个方法检测返回的HTTP状态码和数据类型是否合法，属性acceptableStatusCodes和acceptableContentTypes规定了合法的状态码和数据类型，例如JSONSerialization就把acceptableContentTypes设为@”application/json”, @”text/json”, @”text/javascript”，若不是这三者之一，就验证失败，返回相应的NSError对象。一般子类不需要重写这个方法，只需要设置好acceptableStatusCodes和acceptableContentTypes就行了。
（更多…）

续AFNetworking源码解析<一><二>

本篇说说安全相关的AFSecurityPolicy模块，AFSecurityPolicy用于验证http请求的证书，先来看看http的原理和证书相关的几个问题。

http

http连接建立过程大致是，客户端和服务端建立一个连接，服务端返回一个证书，客户端里存有各个受信任的证书机构根证书，用这些根证书对服务端返回的证书进行验证，经验证如果证书是可信任的，就生成一个pre-master secret，用这个证书的公钥加密后发送给服务端，服务端用私钥解密后得到pre-master secret，再根据某种算法生成master secret，客户端也同样根据这种算法从pre-master secret生成master secret，随后双方的通信都用这个master secret对传输数据进行加密解密。
（更多…）

续AFNetworking2.0源码解析<一>

本篇我们继续来看看AFNetworking的下一个模块 — AFURLRequestSerialization。

AFURLRequestSerialization用于帮助构建NSURLRequest，主要做了两个事情：
1.构建普通请求：格式化请求参数，生成HTTP Header。
2.构建multipart请求。
分别看看它在这两点具体做了什么，怎么做的。
（更多…）

最近看AFNetworking2的源码，mg游戏平台官方网站这个知名网络框架的实现，顺便梳理写下文章。AFNetworking2的大体架构和思路在这篇文章已经说得挺清楚了，就不再赘述了，只说说实现的细节。AFNetworking的代码还在不断更新中，我看的是AFNetworking2.3.1。

本篇先看看AFURLConnectionOperation，AFURLConnectionOperation继承自NSOperation，是一个封装好的任务单元，在这里构建了NSURLConnection，作为NSURLConnection的delegate处理请求回调，做好状态切换，线程管理，可以说是AFNetworking最核心的类，下面分几部分说下看源码时注意的点，最后放上代码的注释。
（更多…）