大家好，又见面了，我是你们的朋友全栈君。

微信搜索：“二十同学” 公众号，欢迎关注一条不一样的成长之路

秒杀系统架构优化思路

一、秒杀业务为什么难做

1）im系统，例如qq或者微博，每个人都读自己的数据（好友列表、群列表、个人信息）；

2）微博系统，每个人读你关注的人的数据，一个人读多个人的数据；

3）秒杀系统，库存只有一份，所有人会在集中的时间读和写这些数据，多个人读一个数据。

例如：小米手机每周二的秒杀，可能手机只有1万部，但瞬时进入的流量可能是几百几千万。

又例如：12306抢票，票是有限的，库存一份，瞬时流量非常多，都读相同的库存。读写冲突，锁非常严重，这是秒杀业务难的地方。那我们怎么优化秒杀业务的架构呢？

二、优化方向

优化方向有两个（今天就讲这两个点）：

（1）将请求尽量拦截在系统上游（不要让锁冲突落到数据库上去）。传统秒杀系统之所以挂，请求都压倒了后端数据层，数据读写锁冲突严重，并发高响应慢，几乎所有请求都超时，流量虽大，下单成功的有效流量甚小。以12306为例，一趟火车其实只有2000张票，200w个人来买，基本没有人能买成功，请求有效率为0。

（2）充分利用缓存，秒杀买票，这是一个典型的读多些少的应用场景，大部分请求是车次查询，票查询，下单和支付才是写请求。一趟火车其实只有2000张票，200w个人来买，最多2000个人下单成功，其他人都是查询库存，写比例只有0.1%，读比例占99.9%，非常适合使用缓存来优化。好，后续讲讲怎么个“将请求尽量拦截在系统上游”法，以及怎么个“缓存”法，讲讲细节。

三、常见秒杀架构

常见的站点架构基本是这样的（绝对不画忽悠类的架构图）

（1）浏览器端，最上层，会执行到一些JS代码

（2）站点层，这一层会访问后端数据，拼html页面返回给浏览器

（3）服务层，向上游屏蔽底层数据细节，提供数据访问

（4）数据层，最终的库存是存在这里的，mysql是一个典型（当然还有会缓存）

这个图虽然简单，但能形象的说明大流量高并发的秒杀业务架构，大家要记得这一张图。

后面细细解析各个层级怎么优化。

四、各层次优化细节

第一层，客户端怎么优化（浏览器层，APP层）

问大家一个问题，大家都玩过微信的摇一摇抢红包对吧，每次摇一摇，就会往后端发送请求么？回顾我们下单抢票的场景，点击了“查询”按钮之后，系统那个卡呀，进度条涨的慢呀，作为用户，我会不自觉的再去点击“查询”，对么？继续点，继续点，点点点。。。有用么？平白无故的增加了系统负载，一个用户点5次，80%的请求是这么多出来的，怎么整？

（a）产品层面，用户点击“查询”或者“购票”后，按钮置灰，禁止用户重复提交请求；

（b）JS层面，限制用户在x秒之内只能提交一次请求；

APP层面，可以做类似的事情，虽然你疯狂的在摇微信，其实x秒才向后端发起一次请求。这就是所谓的“将请求尽量拦截在系统上游”，越上游越好，浏览器层，APP层就给拦住，这样就能挡住80%+的请求，这种办法只能拦住普通用户（但99%的用户是普通用户）对于群内的高端程序员是拦不住的。firebug一抓包，http长啥样都知道，js是万万拦不住程序员写for循环，调用http接口的，这部分请求怎么处理？

第二层，站点层面的请求拦截

怎么拦截？怎么防止程序员写for循环调用，有去重依据么？ip？cookie-id？…想复杂了，这类业务都需要登录，用uid即可。在站点层面，对uid进行请求计数和去重，甚至不需要统一存储计数，直接站点层内存存储（这样计数会不准，但最简单）。一个uid，5秒只准透过1个请求，这样又能拦住99%的for循环请求。

5s只透过一个请求，其余的请求怎么办？缓存，页面缓存，同一个uid，限制访问频度，做页面缓存，x秒内到达站点层的请求，均返回同一页面。同一个item的查询，例如车次，做页面缓存，x秒内到达站点层的请求，均返回同一页面。如此限流，既能保证用户有良好的用户体验（没有返回404）又能保证系统的健壮性（利用页面缓存，把请求拦截在站点层了）。

页面缓存不一定要保证所有站点返回一致的页面，直接放在每个站点的内存也是可以的。优点是简单，坏处是http请求落到不同的站点，返回的车票数据可能不一样，这是站点层的请求拦截与缓存优化。

好，这个方式拦住了写for循环发http请求的程序员，有些高端程序员（黑客）控制了10w个肉鸡，手里有10w个uid，同时发请求（先不考虑实名制的问题，小米抢手机不需要实名制），这下怎么办，站点层按照uid限流拦不住了。

第三层 服务层来拦截（反正就是不要让请求落到数据库上去）

服务层怎么拦截？大哥，我是服务层，我清楚的知道小米只有1万部手机，我清楚的知道一列火车只有2000张车票，我透10w个请求去数据库有什么意义呢？没错，请求队列！

对于写请求，做请求队列，每次只透有限的写请求去数据层（下订单，支付这样的写业务）

1w部手机，只透1w个下单请求去db

3k张火车票，只透3k个下单请求去db

如果均成功再放下一批，如果库存不够则队列里的写请求全部返回“已售完”。

对于读请求，怎么优化？cache抗，不管是memcached还是redis，单机抗个每秒10w应该都是没什么问题的。如此限流，只有非常少的写请求，和非常少的读缓存mis的请求会透到数据层去，又有99.9%的请求被拦住了。

当然，还有业务规则上的一些优化。回想12306所做的，分时分段售票，原来统一10点卖票，现在8点，8点半，9点，…每隔半个小时放出一批：将流量摊匀。

其次，数据粒度的优化：你去购票，对于余票查询这个业务，票剩了58张，还是26张，你真的关注么，其实我们只关心有票和无票？流量大的时候，做一个粗粒度的“有票”“无票”缓存即可。

第三，一些业务逻辑的异步：例如下单业务与 支付业务的分离。这些优化都是结合 业务 来的，我之前分享过一个观点“一切脱离业务的架构设计都是耍流氓”架构的优化也要针对业务。

好了，最后是数据库层

浏览器拦截了80%，站点层拦截了99.9%并做了页面缓存，服务层又做了写请求队列与数据缓存，每次透到数据库层的请求都是可控的。db基本就没什么压力了，闲庭信步，单机也能扛得住，还是那句话，库存是有限的，小米的产能有限，透这么多请求来数据库没有意义。

全部透到数据库，100w个下单，0个成功，请求有效率0%。透3k个到数据，全部成功，请求有效率100%。

五、总结

上文应该描述的非常清楚了，没什么总结了，对于秒杀系统，再次重复下我个人经验的两个架构优化思路：

（1）尽量将请求拦截在系统上游（越上游越好）；

（2）读多写少的常用多使用缓存（缓存抗读压力）；

浏览器和APP：做限速

站点层：按照uid做限速，做页面缓存

服务层：按照业务做写请求队列控制流量，做数据缓存

数据层：闲庭信步

并且：结合业务做优化

六、Q&A

问题1、按你的架构，其实压力最大的反而是站点层，假设真实有效的请求数有1000万，不太可能限制请求连接数吧，那么这部分的压力怎么处理？

答：每秒钟的并发可能没有1kw，假设有1kw，解决方案2个：

（1）站点层是可以通过加机器扩容的，最不济1k台机器来呗。

（2）如果机器不够，抛弃请求，抛弃50%（50%直接返回稍后再试），原则是要保护系统，不能让所有用户都失败。

 

问题2、“控制了10w个肉鸡，手里有10w个uid，同时发请求” 这个问题怎么解决哈？

答：上面说了，服务层写请求队列控制

 

问题3：限制访问频次的缓存，是否也可以用于搜索？例如A用户搜索了“手机”，B用户搜索“手机”，优先使用A搜索后生成的缓存页面？

答：这个是可以的，这个方法也经常用在“动态”运营活动页，例如短时间推送4kw用户app-push运营活动，做页面缓存。

 

问题4：如果队列处理失败，如何处理？肉鸡把队列被撑爆了怎么办？

答：处理失败返回下单失败，让用户再试。队列成本很低，爆了很难吧。最坏的情况下，缓存了若干请求之后，后续请求都直接返回“无票”（队列里已经有100w请求了，都等着，再接受请求也没有意义了）

 

问题5：站点层过滤的话，是把uid请求数单独保存到各个站点的内存中么？如果是这样的话，怎么处理多台服务器集群经过负载均衡器将相同用户的响应分布到不同服务器的情况呢？还是说将站点层的过滤放到负载均衡前？

答：可以放在内存，这样的话看似一台服务器限制了5s一个请求，全局来说（假设有10台机器），其实是限制了5s 10个请求，解决办法：

1）加大限制（这是建议的方案，最简单）

2）在nginx层做7层均衡，让一个uid的请求尽量落到同一个机器上

 

问题6：服务层过滤的话，队列是服务层统一的一个队列？还是每个提供服务的服务器各一个队列？如果是统一的一个队列的话，需不需要在各个服务器提交的请求入队列前进行锁控制？

答：可以不用统一一个队列，这样的话每个服务透过更少量的请求（总票数/服务个数），这样简单。统一一个队列又复杂了。

 

问题7：秒杀之后的支付完成，以及未支付取消占位，如何对剩余库存做及时的控制更新？

答：数据库里一个状态，未支付。如果超过时间，例如45分钟，库存会重新会恢复（大家熟知的“回仓”），给我们抢票的启示是，开动秒杀后，45分钟之后再试试看，说不定又有票哟~

 

问题8：不同的用户浏览同一个商品 落在不同的缓存实例显示的库存完全不一样 请问老师怎么做缓存数据一致或者是允许脏读？

答：目前的架构设计，请求落到不同的站点上，数据可能不一致（页面缓存不一样），这个业务场景能接受。但数据库层面真实数据是没问题的。

 

问题9：就算处于业务把优化考虑“3k张火车票，只透3k个下单请求去db”那这3K个订单就不会发生拥堵了吗？

答：（1）数据库抗3k个写请求还是ok的；（2）可以数据拆分；（3）如果3k扛不住，服务层可以控制透过去的并发数量，根据压测情况来吧，3k只是举例；

 

问题10；如果在站点层或者服务层处理后台失败的话，需不需要考虑对这批处理失败的请求做重放？还是就直接丢弃？

答：别重放了，返回用户查询失败或者下单失败吧，架构设计原则之一是“fail fast”。

 

问题11.对于大型系统的秒杀，比如12306，同时进行的秒杀活动很多，如何分流？

答：垂直拆分

 

问题12、额外又想到一个问题。这套流程做成同步还是异步的？如果是同步的话，应该还存在会有响应反馈慢的情况。但如果是异步的话，如何控制能够将响应结果返回正确的请求方？

答：用户层面肯定是同步的（用户的http请求是夯住的），服务层面可以同步可以异步。

 

问题13、秒杀群提问：减库存是在那个阶段减呢？如果是下单锁库存的话，大量恶意用户下单锁库存而不支付如何处理呢？

答：数据库层面写请求量很低，还好，下单不支付，等时间过完再“回仓”，之前提过了。

 

细聊分布式ID生成方法

一、需求缘起

几乎所有的业务系统，都有生成一个记录标识的需求，例如：

（1）消息标识：message-id

（2）订单标识：order-id

（3）帖子标识：tiezi-id

这个记录标识往往就是数据库中的唯一主键，数据库上会建立聚集索引（cluster index），即在物理存储上以这个字段排序。

 

这个记录标识上的查询，往往又有分页或者排序的业务需求，例如：

（1）拉取最新的一页消息：selectmessage-id/ order by time/ limit 100

（2）拉取最新的一页订单：selectorder-id/ order by time/ limit 100

（3）拉取最新的一页帖子：selecttiezi-id/ order by time/ limit 100

所以往往要有一个time字段，并且在time字段上建立普通索引（non-cluster index）。

 

我们都知道普通索引存储的是实际记录的指针，其访问效率会比聚集索引慢，如果记录标识在生成时能够基本按照时间有序，则可以省去这个time字段的索引查询：

select message-id/ (order by message-id)/limit 100

再次强调，能这么做的前提是，message-id的生成基本是趋势时间递增的。

 

这就引出了记录标识生成（也就是上文提到的三个XXX-id）的两大核心需求：

（1）全局唯一

（2）趋势有序

这也是本文要讨论的核心问题：如何高效生成趋势有序的全局唯一ID。

 

二、常见方法、不足与优化

【常见方法一：使用数据库的 auto_increment 来生成全局唯一递增ID】

优点：

（1）简单，使用数据库已有的功能

（2）能够保证唯一性

（3）能够保证递增性

（4）步长固定

缺点：

（1）可用性难以保证：数据库常见架构是一主多从+读写分离，生成自增ID是写请求，主库挂了就玩不转了

（2）扩展性差，性能有上限：因为写入是单点，数据库主库的写性能决定ID的生成性能上限，并且难以扩展

改进方法：

（1）增加主库，避免写入单点

（2）数据水平切分，保证各主库生成的ID不重复

如上图所述，由1个写库变成3个写库，每个写库设置不同的auto_increment初始值，以及相同的增长步长，以保证每个数据库生成的ID是不同的（上图中库0生成0,3,6,9…，库1生成1,4,7,10，库2生成2,5,8,11…）

改进后的架构保证了可用性，但缺点是：

（1）丧失了ID生成的“绝对递增性”：先访问库0生成0,3，再访问库1生成1，可能导致在非常短的时间内，ID生成不是绝对递增的（这个问题不大，我们的目标是趋势递增，不是绝对递增）

（2）数据库的写压力依然很大，每次生成ID都要访问数据库

为了解决上述两个问题，引出了第二个常见的方案

 

【常见方法二：单点批量ID生成服务】

分布式系统之所以难，很重要的原因之一是“没有一个全局时钟，难以保证绝对的时序”，要想保证绝对的时序，还是只能使用单点服务，用本地时钟保证“绝对时序”。数据库写压力大，是因为每次生成ID都访问了数据库，可以使用批量的方式降低数据库写压力。

如上图所述，数据库使用双master保证可用性，数据库中只存储当前ID的最大值，例如0。ID生成服务假设每次批量拉取6个ID，服务访问数据库，将当前ID的最大值修改为5，这样应用访问ID生成服务索要ID，ID生成服务不需要每次访问数据库，就能依次派发0,1,2,3,4,5这些ID了，当ID发完后，再将ID的最大值修改为11，就能再次派发6,7,8,9,10,11这些ID了，于是数据库的压力就降低到原来的1/6了。

优点：

（1）保证了ID生成的绝对递增有序

（2）大大的降低了数据库的压力，ID生成可以做到每秒生成几万几十万个

缺点：

（1）服务仍然是单点

（2）如果服务挂了，服务重启起来之后，继续生成ID可能会不连续，中间出现空洞（服务内存是保存着0,1,2,3,4,5，数据库中max-id是5，分配到3时，服务重启了，下次会从6开始分配，4和5就成了空洞，不过这个问题也不大）

（3）虽然每秒可以生成几万几十万个ID，但毕竟还是有性能上限，无法进行水平扩展

改进方法：

单点服务的常用高可用优化方案是“备用服务”，也叫“影子服务”，所以我们能用以下方法优化上述缺点（1）：

如上图，对外提供的服务是主服务，有一个影子服务时刻处于备用状态，当主服务挂了的时候影子服务顶上。这个切换的过程对调用方是透明的，可以自动完成，常用的技术是vip+keepalived，具体就不在这里展开。

 

【常见方法三：uuid】

上述方案来生成ID，虽然性能大增，但由于是单点系统，总还是存在性能上限的。同时，上述两种方案，不管是数据库还是服务来生成ID，业务方Application都需要进行一次远程调用，比较耗时。有没有一种本地生成ID的方法，即高性能，又时延低呢？

uuid是一种常见的方案：string ID =GenUUID();

优点：

（1）本地生成ID，不需要进行远程调用，时延低

（2）扩展性好，基本可以认为没有性能上限

缺点：

（1）无法保证趋势递增

（2）uuid过长，往往用字符串表示，作为主键建立索引查询效率低，常见优化方案为“转化为两个uint64整数存储”或者“折半存储”（折半后不能保证唯一性）

 

【常见方法四：取当前毫秒数】

uuid是一个本地算法，生成性能高，但无法保证趋势递增，且作为字符串ID检索效率低，有没有一种能保证递增的本地算法呢？

取当前毫秒数是一种常见方案：uint64 ID = GenTimeMS();

优点：

（1）本地生成ID，不需要进行远程调用，时延低

（2）生成的ID趋势递增

（3）生成的ID是整数，建立索引后查询效率高

缺点：

（1）如果并发量超过1000，会生成重复的ID

我去，这个缺点要了命了，不能保证ID的唯一性。当然，使用微秒可以降低冲突概率，但每秒最多只能生成1000000个ID，再多的话就一定会冲突了，所以使用微秒并不从根本上解决问题。

 

【常见方法五：类snowflake算法】

snowflake是twitter开源的分布式ID生成算法，其核心思想是：一个long型的ID，使用其中41bit作为毫秒数，10bit作为机器编号，12bit作为毫秒内序列号。这个算法单机每秒内理论上最多可以生成1000*(2^12)，也就是400W的ID，完全能满足业务的需求。

借鉴snowflake的思想，结合各公司的业务逻辑和并发量，可以实现自己的分布式ID生成算法。

举例，假设某公司ID生成器服务的需求如下：

（1）单机高峰并发量小于1W，预计未来5年单机高峰并发量小于10W

（2）有2个机房，预计未来5年机房数量小于4个

（3）每个机房机器数小于100台

（4）目前有5个业务线有ID生成需求，预计未来业务线数量小于10个

（5）…

分析过程如下：

（1）高位取从2016年1月1日到现在的毫秒数（假设系统ID生成器服务在这个时间之后上线），假设系统至少运行10年，那至少需要10年*365天*24小时*3600秒*1000毫秒=320*10^9，差不多预留39bit给毫秒数

（2）每秒的单机高峰并发量小于10W，即平均每毫秒的单机高峰并发量小于100，差不多预留7bit给每毫秒内序列号

（3）5年内机房数小于4个，预留2bit给机房标识

（4）每个机房小于100台机器，预留7bit给每个机房内的服务器标识

（5）业务线小于10个，预留4bit给业务线标识

这样设计的64bit标识，可以保证：

（1）每个业务线、每个机房、每个机器生成的ID都是不同的

（2）同一个机器，每个毫秒内生成的ID都是不同的

（3）同一个机器，同一个毫秒内，以序列号区区分保证生成的ID是不同的

（4）将毫秒数放在最高位，保证生成的ID是趋势递增的

缺点：

（1）由于“没有一个全局时钟”，每台服务器分配的ID是绝对递增的，但从全局看，生成的ID只是趋势递增的（有些服务器的时间早，有些服务器的时间晚）

最后一个容易忽略的问题：

生成的ID，例如message-id/ order-id/ tiezi-id，在数据量大时往往需要分库分表，这些ID经常作为取模分库分表的依据，为了分库分表后数据均匀，ID生成往往有“取模随机性”的需求，所以我们通常把每秒内的序列号放在ID的最末位，保证生成的ID是随机的。

又如果，我们在跨毫秒时，序列号总是归0，会使得序列号为0的ID比较多，导致生成的ID取模后不均匀。解决方法是，序列号不是每次都归0，而是归一个0到9的随机数，这个地方。

 

一分钟了解互联网动静分离架构

一、静态页面

静态页面，是指互联网架构中，几乎不变的页面(或者变化频率很低)，例如：

• 首页等html页面

• js/css等样式文件

• jpg/apk等资源文件

静态页面，有与之匹配的技术架构来加速，例如：

• CDN

• nginx

• squid/varnish

 

二、动态页面

动态页面，是指互联网架构中，不同用户不同场景访问，都不一样的页面，例如：

• 百度搜索结果页

• 淘宝商品列表页

• 速运个人订单中心页

这些页面，不同用户，不同场景访问，大都会动态生成不同的页面。

 

动态页面，有与之匹配的技术架构，例如：

• 分层架构

• 服务化架构

• 数据库，缓存架构

 

三、互联网动静分离架构

动静分离是指，静态页面与动态页面分开不同系统访问的架构设计方法。

一般来说：

• 静态页面访问路径短，访问速度快，几毫秒

• 动态页面访问路径长，访问速度相对较慢(数据库的访问，网络传输，业务逻辑计算)，几十毫秒甚至几百毫秒，对架构扩展性的要求更高

• 静态页面与动态页面以不同域名区分

 

四、页面静态化

既然静态页面访问快，动态页面生成慢，有没有可能，将原本需要动态生成的站点提前生成好，使用静态页面加速技术来访问呢？

这就是互联网架构中的“页面静态化”优化技术。

 

举例，如下图，58同城的帖子详情页，原本是需要动态生成的：

 

• 浏览器发起http请求，访问/detail/12348888x.shtml 详情页

• web-server层从RESTful接口中，解析出帖子id是12348888

• service层通过DAO层拼装SQL语句，访问数据库

• 最终获取数据，拼装html返回浏览器

 

而“页面静态化”是指，将帖子ID为12348888的帖子12348888x.shtml提前生成好，由静态页面相关加速技术来加速：

这样的话，将极大提升访问速度，减少访问时间，提高用户体验。

 

五、页面静态化的适用场景

页面静态化优化后速度会加快，那能不能所有的场景都使用这个优化呢？哪些业务场景适合使用这个架构优化方案呢？

 

一切脱离业务的架构设计都是耍流氓，页面静态化，适用于：总数据量不大，生成静态页面数量不多的业务。例如：

• 58速运的城市页只有几百个，就可以用这个优化，只需提前生成几百个城市的“静态化页面”即可

• 一些二手车业务，只有几万量二手车库存，也可以提前生成这几万量二手车的静态页面

• 像58同城这样的信息模式业务，有几十亿的帖子量，就不太适合于静态化（碎片文件多，反而访问慢）

六、总结

“页面静态化”是一种将原本需要动态生成的站点提前生成静态站点的优化技术。

总数据量不大，生成静态页面数量不多的业务，非常适合于“页面静态化”优化。

 

数据库读写分离架构，为什么我不喜欢

RD：单库数据量太大，数据库扛不住了，我要申请一个数据库从库，读写分离。

DBA：数据量多少？

RD：5000w左右。

DBA：读写吞吐量呢？

RD：读QPS约200，写QPS约30左右。

对于互联网某些业务场景，并不是很喜欢数据库读写分离架构

一、读写分离

什么是数据库读写分离？

答：一主多从，读写分离，主动同步，是一种常见的数据库架构，一般来说：

• 主库，提供数据库写服务

• 从库，提供数据库读服务

• 主从之间，通过某种机制同步数据，例如mysql的binlog

一个组从同步集群通常称为一个“分组”。

 

分组架构究竟解决什么问题？

答：大部分互联网业务读多写少，数据库的读往往最先成为性能瓶颈，如果希望：

• 线性提升数据库读性能

• 通过消除读写锁冲突提升数据库写性能

此时可以使用分组架构。

 

一句话，分组主要解决“数据库读性能瓶颈”问题，在数据库扛不住读的时候，通常读写分离，通过增加从库线性提升系统读性能。

 

二、水平切分

什么是数据库水平切分？

答：水平切分，也是一种常见的数据库架构，一般来说：

• 每个数据库之间没有数据重合，没有类似binlog同步的关联

• 所有数据并集，组成全部数据

• 会用算法，来完成数据分割，例如“取模”

一个水平切分集群中的每一个数据库，通常称为一个“分片”。

 

水平切分架构究竟解决什么问题？

答：大部分互联网业务数据量很大，单库容量容易成为瓶颈，如果希望：

• 线性降低单库数据容量

• 线性提升数据库写性能

此时可以使用水平切分架构。

 

一句话总结，水平切分主要解决“数据库数据量大”问题，在数据库容量扛不住的时候，通常水平切分。

 

三、为什么不喜欢读写分离

对于互联网大数据量，高并发量，高可用要求高，一致性要求高，前端面向用户的业务场景，如果数据库读写分离：

• 数据库连接池需要区分：读连接池，写连接池

• 如果要保证读高可用，读连接池要实现故障自动转移

• 有潜在的主库从库一致性问题

• 如果面临的是“读性能瓶颈”问题，增加缓存可能来得更直接，更容易一点

• 关于成本，从库的成本比缓存高不少

• 对于云上的架构，以阿里云为例，主库提供高可用服务，从库不提供高可用服务

 

所以，上述业务场景下，楼主建议使用缓存架构来加强系统读性能，替代数据库主从分离架构。

 

当然，使用缓存架构的潜在问题：如果缓存挂了，流量全部压到数据库上，数据库会雪崩。不过幸好，云上的缓存一般都提供高可用的服务。

 

四、总结

• 读写分离，解决“数据库读性能瓶颈”问题

• 水平切分，解决“数据库数据量大”问题

• 对于互联网大数据量，高并发量，高可用要求高，一致性要求高，前端面向用户的业务场景，微服务缓存架构，可能比数据库读写分离架构更合适

互联网分层架构的本质

 

上图是一个典型的互联网分层架构：

• 客户端层：典型调用方是browser或者APP

• 站点应用层：实现核心业务逻辑，从下游获取数据，对上游返回html或者json

• 数据-缓存层：加速访问存储

• 数据-数据库层：固化数据存储

 

如果实施了服务化，这个分层架构图可能是这样：

中间多了一个服务层。

 

同一个层次的内部，例如端上的APP，以及web-server，也都有进行MVC分层：

• view层：展现

• control层：逻辑

• model层：数据

 

可以看到，每个工程师骨子里，都潜移默化的实施着分层架构。

 

那么，互联网分层架构的本质究竟是什么呢？

如果我们仔细思考会发现，不管是跨进程的分层架构，还是进程内的MVC分层，都是一个“数据移动”，然后“被处理”和“被呈现”的过程，归根结底一句话：互联网分层架构，是一个数据移动，处理，呈现的过程，其中数据移动是整个过程的核心。

 

如上图所示：

数据处理和呈现要CPU计算，CPU是固定不动的：

• db/service/web-server都部署在固定的集群上

• 端上，不管是browser还是APP，也有固定的CPU处理

 

数据是移动的：

• 跨进程移动：数据从数据库和缓存里，转移到service层，到web-server层，到client层

• 同进程移动：数据从model层，转移到control层，转移到view层

 

数据要移动，所以有两个东西很重要：

• 数据传输的格式

• 数据在各层次的形态

 

先看数据传输的格式，即协议很重要：

• service与db/cache之间，二进制协议/文本协议是数据传输的载体

• web-server与service之间，RPC的二进制协议是数据传输的载体

• client和web-server之间，http协议是数据传输的载体

 

再看数据在各层次的形态，以用户数据为例：

• db层，数据是以“行”为单位存在的row(uid, name, age)

• cache层，数据是以kv的形式存在的kv(uid -> User)

• service层，会把row或者kv转化为对程序友好的User对象

• web-server层，会把对程序友好的User对象转化为对http友好的json对象

• client层：最终端上拿到的是json对象

 

结论：互联网分层架构的本质，是数据的移动。

 

为什么要说这个，这将会引出“分层架构演进”的核心原则与方法：

• 让上游更高效的获取与处理数据，复用

• 让下游能屏蔽数据的获取细节，封装

 

弄清楚这个原则与方法，再加上一些经验积累，就能回答网友经常在评论中提出的这些问题了：

• 是否需要引入DAO层，什么时机引入

• 是否需要服务化，什么时机服务化

• 是否需要抽取通用中台业务，什么时机抽取

• 是否需要前后端分离，什么时机分离

（网友们的这些提问，其实很难回答。在不了解业务发展阶段，业务规模，数据量并发量的情况下，妄下YES或NO的结论，本身就是不负责任的。）

更具体的分层架构演进细节，下一篇和大家细究。

 

总结

• • 互联网分层架构的本质，是数据的移动

  • 互联网分层架构中，数据的传输格式（协议）与数据在各层次的形态很重要

  • 互联网分层架构演进的核心原则与方法：封装与复用

 

互联网分层架构之-DAO与服务化

互联网分层架构的本质，是数据的移动。

互联网分层架构演进的核心原则：

• 让上游更高效的获取与处理数据，复用

• 让下游能屏蔽数据的获取细节，封装

本文主要解答两个问题：

• 后端架构，什么时候进行DAO层的抽象

• 后端架构，什么时候进行数据服务层的抽象

 

核心问题一：什么时候进行DAO层的抽象

一个业务系统最初的后端结构如上：

• web-server层从db层获取数据并进行加工处理

• db层存储数据

 

此时，web-server层如何获取底层的数据呢？

web-server层获取数据的一段伪代码如上，不用纠结代码的细节，也不用纠结不同编程语言与不同数据库驱动的差异，其获取数据的过程大致为：

• 创建一个与数据库的连接，初始化资源

• 根据业务拼装一个SQL语句

• 通过连接执行SQL语句，并获得结果集

• 通过游标遍历结果集，取出每行数据，亦可从每行数据中取出属性数据

• 关闭数据库连接，回收资源

 

如果业务不复杂，这段代码写1次2次还可以，但如果业务越来越复杂，每次都这么获取数据，就略显低效了，有大量冗余、重复、每次必写的代码。

 

如何让数据的获取更加高效快捷呢？

 

通过技术手段实现：

• 表与类的映射

• 属性与成员的映射

• SQL与函数的映射

绝大部分公司正在用的ORM，DAO等技术，就是一种分层抽象，可以提高数据获取的效率，屏蔽连接，游标，结果集这些复杂性。

 

 

结论

当手写代码从DB中获取数据，成为通用痛点的时候，就应该抽象出DAO层，简化数据获取过程，提高数据获取效率，向上游屏蔽底层的复杂性。

 

核心问题二：什么时候要进行数据服务层的抽象

抽象出DAO层之后，系统架构并不会一成不变：

• 随着业务越来越复杂，业务系统会不断进行垂直拆分

• 随着数据量越来越大，数据库会进行水平切分

• 随着读并发的越来越大，会增加缓存降低数据库的压力

 

于是系统架构变成了这个样子：

业务系统垂直拆分，数据库水平切分，缓存这些都是常见的架构优化手段。

 

此时，web-server层如何获取底层的数据呢？

根据楼主的经验，以用户数据为例，流程一般是这样的：

• 先查缓存：先用uid尝试从缓存获取数据，如果cache hit，数据获取成功，返回User实体，流程结束

• 确定路由：如果cache miss，先查询路由配置，确定uid落在哪个数据库实例的哪个库上

• 查询DB：通过DAO从对应库获取uid对应的数据实体User

• 插入缓存：将kv(uid, User)放入缓存，以便下次缓存查询数据能够命中缓存

 

如果业务不复杂，这段代码写1次2次还可以，但如果业务越来越复杂，每次都这么获取数据，就略显低效了，有大量冗余、重复、每次必写的代码。

 

特别的，业务垂直拆分成非常多的子系统之后：

• 一旦底层有稍许变化，所有上游的系统都需要升级修改

• 子系统之间很可能出现代码拷贝

• 一旦拷贝代码，出现一个bug，多个子系统都需要升级修改

 

不相信业务会垂直拆分成多个子系统？举两个例子：

• 58同城有招聘、房产、二手、二手车、黄页等5大头部业务，都需要访问用户数据

• 58到家有月嫂、保姆、丽人、速运、平台等多个业务，也都需要访问用户数据

如果每个子系统都需要关注缓存，分库，读写分离的复杂性，调用层会疯掉的。

 

如何让数据的获取更加高效快捷呢？

服务化，数据服务层的抽象势在必行。

 

通过抽象数据服务层：

• web-server层可以通过RPC接口，像调用本地函数一样调用远端的数据

• 数据服务层，只有这一处需要关注缓存，分库，读写分离这些复杂性

结论

当业务越来越复杂，垂直拆分的系统越来越多，数据库实施了水平切分，数据层实施了缓存加速之后，底层数据获取复杂性成为通用痛点的时候，就应该抽象出数据服务层，简化数据获取过程，提高数据获取效率，向上游屏蔽底层的复杂性。

互联网分层架构是一个很有意思的问题，服务化的引入，并不是越早越好：

• 请求处理时间可能会增加

• 运维可能会更加复杂

• 定位问题可能会更加麻烦

千万别鲁莽的在“微服务”大流之下，草率的进行微服务改造，看似“高大上架构”的背后，隐藏着更多并未接触过的“大坑”。还是那句话，架构和业务的特点和阶段有关：一切脱离业务的架构设计，都是耍流氓。

这一篇先到这里，分层架构，还有很多内容要和大家聊：

• 后端架构，是否需要抽取中台业务，什么时机抽取

• 后端架构，是否需要前后端分离，什么时机分离

• 前端架构，如何进行分层实践

末了，再次强调下，互联网分层架构的本质，是数据的移动。

互联网分层架构演进的核心原则，是让上游更高效的获取与处理数据，让下游能屏蔽掉数据的复杂性获取细节。

 

互联网架构为什么要做服务化？

近期参加一些业界的技术大会，“微服务架构”的话题非常之火，也在一些场合聊过服务化架构实践，最近几期文章期望用通俗易懂的语言聊聊了个人对服务化以及微服务架构的理解，希望能给大伙一些启示。如果有遗漏，也欢迎大家补充。

 

一、互联网高可用架构，为什么要服务化？

【服务化之前高可用架构】

在服务化之前，互联网的高可用架构大致是这样一个架构：

（1）用户端是浏览器browser，APP客户端

（2）后端入口是高可用的nginx集群，用于做反向代理

（3）中间核心是高可用的web-server集群，研发工程师主要编码工作就是在这一层

（4）后端存储是高可用的db集群，数据存储在这一层

 

更典型的，web-server层是通过DAO/ORM等技术来访问数据库的。

 

可以看到，最初都是没有服务层的，此时架构会碰到一些什么痛点呢？

【架构痛点一：代码到处拷贝】

举一个最常见的业务的例子->用户数据的访问，绝大部分公司都有一个数据库存储用户数据，各个业务都有访问用户数据的需求：

在有用户服务之前，各个业务线都是自己通过DAO写SQL访问user库来存取用户数据，这无形中就导致了代码的拷贝。

 

【架构痛点二：复杂性扩散】

随着并发量的越来越高，用户数据的访问数据库成了瓶颈，需要加入缓存来降低数据库的读压力，于是架构中引入了缓存，由于没有统一的服务层，各个业务线都需要关注缓存的引入导致的复杂性：

对于用户数据的写请求，所有业务线都要升级代码：

（1）先淘汰cache

（2）再写数据

对于用户数据的读请求，所有业务线也都要升级代码：

（1）先读cache，命中则返回

（2）没命中则读数据库

（3）再把数据放入cache

这个复杂性是典型的“业务无关”的复杂性，业务方需要被迫升级。

 

随着数据量的越来越大，数据库需要进行水平拆分，于是架构中又引入了分库分表，由于没有统一的服务层，各个业务线都需要关注分库分表的引入导致的复杂性：

这个复杂性也是典型的“业务无关”的复杂性，业务方需要被迫升级。

包括bug的修改，发现一个bug，多个地方都需要修改。

 

【架构痛点三：库的复用与耦合】

服务化并不是唯一的解决上述两痛点的方法，抽象出统一的“库”是最先容易想到的解决：

（1）代码拷贝

（2）复杂性扩散

的方法。抽象出一个user.so，负责整个用户数据的存取，从而避免代码的拷贝。至于复杂性，也只有user.so这一个地方需要关注了。

 

解决了旧的问题，会引入新的问题，库的版本维护与业务线之间代码的耦合：

业务线A将user.so由版本1升级至版本2，如果不兼容业务线B的代码，会导致B业务出现问题；

业务线A如果通知了业务线B升级，则是的业务线B会无故做一些“自身业务无关”的升级，非常郁闷。当然，如果各个业务线都是拷贝了一份代码则不存在这个问题。

 

【架构痛点四：SQL质量得不到保障，业务相互影响】

业务线通过DAO访问数据库：

本质上SQL语句还是各个业务线拼装的，资深的工程师写出高质量的SQL没啥问题，经验没有这么丰富的工程师可能会写出一些低效的SQL，假如业务线A写了一个全表扫描的SQL，导致数据库的CPU100%，影响的不只是一个业务线，而是所有的业务线都会受影响。

 

【架构痛点五：疯狂的DB耦合】

业务线不至访问user数据，还会结合自己的业务访问自己的数据：

典型的，通过join数据表来实现各自业务线的一些业务逻辑。

这样的话，业务线A的table-user与table-A耦合在了一起，业务线B的table-user与table-B耦合在了一起，业务线C的table-user与table-C耦合在了一起，结果就是：table-user，table-A，table-B，table-C都耦合在了一起。

随着数据量的越来越大，业务线ABC的数据库是无法垂直拆分开的，必须使用一个大库（疯了，一个大库300多个业务表 =_=）。

 

【架构痛点六：…】

 

二、服务化解决什么问题？

为了解决上面的诸多问题，互联网高可用分层架构演进的过程中，引入了“服务层”。

以上文中的用户业务为例，引入了user-service，对业务线响应所用用户数据的存取。引入服务层有什么好处，解决什么问题呢？

【好处一：调用方爽】

有服务层之前：业务方访问用户数据，需要通过DAO拼装SQL访问

有服务层之后：业务方通过RPC访问用户数据，就像调用一个本地函数一样，非常之爽

User = UserService::GetUserById(uid);

传入一个uid，得到一个User实体，就像调用本地函数一样，不需要关心序列化，网络传输，后端执行，网络传输，范序列化等复杂性。

 

【好处二：复用性，防止代码拷贝】

这个不展开叙述，所有user数据的存取，都通过user-service来进行，代码只此一份，不存在拷贝。

升级一处升级，bug修改一处修改。

 

【好处三：专注性，屏蔽底层复杂度】

在没有服务层之前，所有业务线都需要关注缓存、分库分表这些细节。

 

在有了服务层之后，只有服务层需要专注关注底层的复杂性了，向上游屏蔽了细节。

 

【好处四：SQL质量得到保障】

原来是业务向上游直接拼接SQL访问数据库。

 

有了服务层之后，所有的SQL都是服务层提供的，业务线不能再为所欲为了。底层服务对于稳定性的要求更好的话，可以由更资深的工程师维护，而不是像原来SQL难以收口，难以控制。

 

【好处五：数据库解耦】

原来各个业务的数据库都混在一个大库里，相互join，难以拆分。

服务化之后，底层的数据库被隔离开了，可以很方便的拆分出来，进行扩容。

 

【好处六：提供有限接口，无限性能】

在服务化之前，各业务线上游想怎么操纵数据库都行，遇到了性能瓶颈，各业务线容易扯皮，相互推诿。

服务化之后，服务只提供有限的通用接口，理论上服务集群能够提供无限性能，性能出现瓶颈，服务层一处集中优化。

 

业务层是否也需要服务化？

观点：

• 互联网分层架构的本质，是数据的移动

• 互联网分层架构演进的核心原则：是让上游更高效的获取与处理数据，让下游能屏蔽数据的获取细节

• 当手写代码从DB中获取数据，成为通用痛点的时候，就应该抽象出DAO层，简化数据获取过程，提高数据获取效率，向上游屏蔽底层的复杂性

• 当业务越来越复杂，垂直拆分的系统越来越多，数据库实施了水平切分，数据层实施了缓存加速之后，底层数据获取复杂性成为通用痛点的时候，就应该抽象出数据服务层，简化数据获取过程，提高数据获取效率，向上游屏蔽底层的复杂性

文本将要解答的问题是：

• 基础数据的访问需要服务化，业务层是否需要服务化

• 如果需要服务化，什么时候服务化

 

基础数据的访问服务化之后，一个业务系统的后端架构如上：

• web-server通过RPC接口，从基础数据service获取数据

• 基础数据service通过DAO，从db/cache获取数据

• db/cache存储数据

 

随着时间的推移，系统架构并不会一成不变：

• 随着业务越来越复杂，业务会不断进行垂直拆分

• 随着数据越来越复杂，基础数据service也会越来越多

 

于是系统架构变成了上图这个样子，业务垂直拆分，有若干个基础数据服务：

• 垂直业务要通过多个RPC接口访问不同的基础数据service，service共有是服务化的特征

• 每个基础数据service访问自己的数据存储，数据私有也是服务化的特征

 

这个架构图中的依赖关系是不是看上去很别扭？

• 基础数据service与存储层之前连接关系很清晰

• 业务web-server层与基础数据service层之间的连接关系错综复杂，变成了蜘蛛网

 

再举一个更具体的例子，58同城列表页web-server如何获取底层的数据？

• 首先调用商业基础service，获取商业广告帖子数据，用于顶部置顶/精准的广告帖子展示

• 再调用搜索基础service，获取自然搜索帖子数据，用于中部自然搜索帖子展示

• 再调用推荐基础service，获取推荐帖子数据，用于底部推荐帖子展示

• 再调用用户基础service，获取用户数据，用于右侧用户信息展示

• …

 

如果只有一个列表页这么写还行，但如果有招聘、房产、二手、二手车、黄页…等多个大部分是共性数据，少部分是个性数据的列表页，每次都这么获取数据，就略显低效了，有大量冗余、重复、每次必写的代码。

 

特别的，不同业务上游列表页都依赖于底层若干相同服务：

• 一旦一个服务RPC接口有稍许变化，所有上游的系统都需要升级修改

• 子系统之间很可能出现代码拷贝

• 一旦拷贝代码，出现一个bug，多个子系统都需要升级修改

 

如何让数据的获取更加高效快捷呢？

业务服务化，通用业务服务层的抽象势在必行。

 

通过抽象通用业务服务层，例如58同城“通用列表服务”：

• web-server层，可以通过RPC接口，像调用本地函数一样，调用通用业务service，一次性获取所有通用数据

• 通用业务service，也可以通过多次调用基础数据service提供的RPC接口，分别获取数据，底层数据获取的复杂性，全都屏蔽在了此处 

 

是不是连接关系也看起来更清晰？

 

这样的好处是：

• 复杂的从基础服务获取数据代码，只有在通用业务service处写了一次，没有代码拷贝

• 底层基础数据service接口发生变化，只有通用业务service一处需要升级修改

• 如果有bug，不管是底层基础数据service的bug，还是通用业务service的bug，都只有一处需要升级修改

• 业务web-server获取数据更便捷，获取所有数据，只需一个RPC接口调用

 

结论：

当业务越来越复杂，垂直拆分的系统越来越多，基础数据服务越来越多，底层数据获取复杂性成为通用痛点的时候，就应该抽象出通用业务服务，简化数据获取过程，提高数据获取效率，向上游屏蔽底层的复杂性。

 

最后再强调两点：

• 是否需要抽象通用业务服务，和业务复杂性，以及业务发展阶段有关，不可一概而论

• 需要抽象什么通用业务服务，和具体业务相关

 

互联网分层架构，为啥要前后端分离？

通用业务服务化之后，系统的典型后端结构如上：

• web-server通过RPC接口，从通用业务服务获取数据

• biz-service通过RPC接口，从多个基础数据service获取数据

• 基础数据service通过DAO，从独立db/cache获取数据

• db/cache存储数据

 

随着时间的推移，系统架构并不会一成不变，业务越来越复杂，改版越来越多，此时web-server层虽然使用了MVC架构，但以下诸多痛点是否似曾相识？

• 产品追求绚丽的效果，并对设备兼容性要求高，这些需求不断折磨着使用MVC的Java工程师们（本文以Java举例）

• 不管是PC，还是手机H5，还是APP，应用前端展现的变化频率远远大于后端逻辑的变化频率（感谢那些喜欢做改版的产品经理），改velocity模版并不是Java工程师喜欢和擅长的工作

 

此时，为了缓解这些问题，一般会成立单独的前端FE部门，来负责交互与展现的研发，其职责与后端Java工程师分离开，但痛点依然没有完全解决：

• 一点点展现的改动，需要Java工程师们重新编译，打包，上线，重启tomcat，效率极低

• 原先Java工程师负责所有MVC的研发工作，现在分为Java和FE两块，需要等前端和后端都完成研发，才能一起调试整体效果，不仅增加了沟通成本，任何一块出问题，都可能导致项目延期

 

更具体的，看一个这样的例子，最开始产品只有PC版本，此时其系统分层架构如下：

客户端，web-server，service，非常清晰。

 

随着业务的发展，产品需要新增Mobile版本，Mobile版本和PC版本大部分业务逻辑都一样，唯一的区别是屏幕比较小：

• 信息展现的条数会比较少，即调用service服务时，传入的参数会不一样

• 产品功能会比较少，大部分service的调用一样，少数service不需要调用

• 展现，交互会有所区别

 

由于工期较紧，Mobile版本的web-server一般怎么来呢？

没错，把PC版本的工程拷贝一份，然后再做小量的修改：

• service调用的参数有些变化

• 大部分service的调用一样，少数service的调用去掉

• 修改展现，交互相关的代码

 

业务继续发展，产品又需要新增APP版本，APP版本和Mobile版本业务逻辑完全相同，唯一的区别是：

• Mobile版本返回html格式的数据，APP版本返回json格式的数据，然后进行本地渲染

 

由于工期较紧，APP版本的web-server一般怎么来呢？

没错，把Mobile版本的工程拷贝一份，然后再做小量的修改：

• 把拼装html数据的代码，修改为拼装json数据

 

这么迭代，演化，发展，架构会变成这个样子：

• 端，是PC，Mobile，APP

• web-server接入，是PC站，M站，APP站

• 服务层，通用的业务服务，以及基础数据服务

 

这个架构图中的依赖关系是不是看上去很别扭？

• 端到web-server之间连接关系很清晰

• web-server与service之间的连接关系变成了蜘蛛网

 

PC/H5/APP的web-server层大部分业务是相同的，只有少数的逻辑/展现/交互不一样：

• 一旦一个服务RPC接口有稍许变化，所有web-server系统都需要升级修改

• web-server之间存在大量代码拷贝

• 一旦拷贝代码，出现一个bug，多个子系统都需要升级修改

 

如何让数据的获取更加高效快捷，如何让数据生产与数据展现解耦分离呢？

前后端分离的分层抽象势在必行。

通过前后端分离分层抽象：

• 站点展示层，node.js，负责数据的展现与交互，由FE维护

• 站点数据层，web-server，负责业务逻辑与json数据接口的提供，由Java工程师维护

 

这样的好处是：

• 复杂的业务逻辑与数据生成，只有在站点数据层处写了一次，没有代码拷贝

• 底层service接口发生变化，只有站点数据层一处需要升级修改

• 底层service如果有bug，只有站点数据层一处需要升级修改

• 站点展现层可以根据产品的不同形态，传入不同的参数，调用不同的站点数据层接口

 

除此之外：

• 产品追求绚丽的效果，并对设备兼容性要求高，不再困扰Java工程师，由更专业的FE对接

• 一点点展现的改动，不再需要Java工程师们重新编译，打包，上线，重启tomcat

• 约定好json接口后，Java和FE分开开发，FE可以用mock的接口自测，不再等待一起联调

 

结论：

当业务越来越复杂，端上的产品越来越多，展现层的变化越来越快越来越多，站点层存在大量代码拷贝，数据获取复杂性成为通用痛点的时候，就应该进行前后端分离分层抽象，简化数据获取过程，提高数据获取效率，向上游屏蔽底层的复杂性。

最后再强调两点：

• 是否需要前后端分离，和业务复杂性，以及业务发展阶段有关，不可一概而论

• 本文强调的前后端分离的思路，实际情况下有多种实现方式，文章并没有透彻展开实现细节