<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>TBWORKs</title>
    <description>Tommy&apos;s blog for techs.</description>
    <link>https://tbwork.github.io/</link>
    <atom:link href="https://tbwork.github.io/feed.xml" rel="self" type="application/rss+xml"/>
    <pubDate>Sat, 25 Apr 2026 14:11:34 +0000</pubDate>
    <lastBuildDate>Sat, 25 Apr 2026 14:11:34 +0000</lastBuildDate>
    <generator>Jekyll v3.10.0</generator>
    
      <item>
        <title>提示词编程心得分享——8个最佳实践</title>
        <description>&lt;h2 id=&quot;1生成式ai是一个计算量有限的函数单次输入要求越多输出质量越会下降&quot;&gt;1.生成式AI是一个计算量有限的函数，单次输入要求越多，输出质量越会下降!&lt;/h2&gt;

AI和人在这个方面很像，人处理事情也是有“容量”上限的，我们一次性分配给下属的任务越多，他们交付的质量大概率也会越低。时刻记住这一点！

因此，对于特别庞大的提示词上下文，我们心里有一些“可能会得到差答案”的预期。这时候怎么办？

人工归纳、重新开一个窗口，开启一个新对话。因为随着对话内容不断变多，上下文中一定充斥着很多跟我们下一个问题不相关的东西，这时候，我们就需要“剥离”出子问题，再去发问。

&lt;blockquote&gt;
  相信随着AGI的发展，人工归纳会慢慢变成自动归纳，但是目前还是自己识别比较靠谱。
&lt;/blockquote&gt;

&lt;h2 id=&quot;2越是宽泛笼统的输入输出就越感觉未经打磨&quot;&gt;2.越是宽泛、笼统的输入，输出就越感觉“未经打磨”。&lt;/h2&gt;

比如，我们就用一句话提示词“请帮我写一个社交网站”，得到的结果一定是差强人意的。因为一个良好体验的社交网站需要打磨的地方太多了，你的提示词如果不能体现这些打磨的点，那结果大概率不会让你满意。
这里有一个很有趣的tradeoff：

如果写的特别粗糙，那就跟我们想要的大相径庭，需要人工修改的太多；

如果每个细节都用提示词写出来，那就太麻烦了，和直接写代码没啥区别了；

所以最佳实践是：像画素描那样去打磨你的作品，素描时一般会先画出轮廓，然后在细化细节。

所以我们的提示词也是这样的流程：

1、先编写可以产出一个轮廓性系统的提示词，不要纠结某个具体的细节，甚至有些细节你可以主动提示：“这个部分先空着，用一个placeholder替代”，这样可以节省很多token和时间。

2、然后针对不同的模块、功能，再编写更多的提示词，逐步的细化。

&lt;h2 id=&quot;3越是冷门定制化逻辑ai的回答越是无法让你满意&quot;&gt;3.越是“冷门”/“定制化”逻辑，AI的回答越是无法让你满意。&lt;/h2&gt;

相对应的越是标准的问题，AI回答的答案与你想要的越是接近。比如你让它写一个归并排序算法、Dijkstra算法，它很快可以写出来。

如果我们让AI实现一个微信头像的选取和编辑功能，它怎么都实现不了你想要的效果（所有模型我都测试过，结果很不如人意）。因为微信的头像选取功能其实有很多精妙的小细节设计：比如它的图像是可以以任意位置为中心放大的，而GPT学习数据中不可能有微信的代码，因此它所理解的都是一些标准的放大和缩小方案（以图片中心为原点进行缩放），更别说坐标转换算法了。

这个时候你就需要“建模”成更加通用的一些问法，必要的时候自己设计逻辑，让它去按步骤实现。相比直接写代码，提示词还是相对轻松很多的。

这里还有一个重点——实际的企业级软件开发99%都是个性化的，比如阿里和京东的代码一定都各不相同，设计思路可能有类似的，但细节大多都不同。对于一个复杂的生产级系统，代码结构的编排非常重要，因为每家公司、每种业务都有各自的特殊需求，因此这不是一个“标准”问题，AI的回答不会太如人意（原则2），因此我们需要自己来构建一个“逻辑自洽”的代码架构。

比如对于前端APP项目来说可以分成api、model、pageModel、pages、database、repo。只有我们自己讲逻辑了、AI才可以输出的更加完美。

&lt;h2 id=&quot;4如果你不讲道理和原则ai也不会讲道理和原则&quot;&gt;4.如果你不讲“道理”和“原则”，AI也不会讲“道理”和“原则”。&lt;/h2&gt;

这个特性非常有趣，以前主管、领导给下面的同学分配任务，很可能只是说个大概，甚至自己都没有完全想清楚，就用自己的“现场扭曲力”强压了下去。

下属也只能硬着头皮去做，发现了不对也不会吭声；AI则不会说谎，如果你自己的需求不讲道理，它的结果一定不会让你太满意。

因此，当你浅思考无法得到好的结果的时候，这里不要偷懒了，自己花时间想清楚了分配给AI去做吧。 可以先跟AI进行开放式的聊天，帮助自己理清思路，确定逻辑上没问题之后，再编写任务提示词。

</description>
        <pubDate>Thu, 07 Aug 2025 11:30:00 +0000</pubDate>
        <link>https://tbwork.github.io/2025/08/07/ai-code/</link>
        <guid isPermaLink="true">https://tbwork.github.io/2025/08/07/ai-code/</guid>
        
        <category>ChatGPT</category>
        
        <category>AGI-Code</category>
        
        <category>AI编码</category>
        
        
        <category>AI编程</category>
        
      </item>
    
      <item>
        <title>DAPP决策指南——要不要把自己的业务DAPP化</title>
        <description>&lt;h2 id=&quot;区块链的核心意义在于去中心化&quot;&gt;区块链的核心意义在于去中心化&lt;/h2&gt;

白话解读：如果希望某一项业务不是一个机构/国家/个人说了算，不应该就他一个人赚钱，而应该谁都可以参与进来分钱，那么可能就可以考虑通过区块链重构，去中心化。注意是可能，而不是一定。

区块链最本质的核心就是去中心化。正是因为去中心化后，由于人们会担心没有主心骨，万一有人偷奸耍滑怎么办，这才有了区块链的另一项突破：分布式账本的法定数量理论决定了没有人可以偷奸耍滑。

&lt;h2 id=&quot;是否做成dapp的指导原则&quot;&gt;是否做成DAPP的指导原则&lt;/h2&gt;

有一点可以肯定的是，如果您的业务就是通过靠中心机构或者国家保障来收取利润的，那么做成DAPP就是自断财路。

所以要不要做成DAPP的原则只有一个——去中心化是不是你业务的核心诉求？ 蹭热点没有任何意义。

我们也可以反过来问一下：

&lt;ul&gt;
  &lt;li&gt;
    不去中心化，模式就没法玩了吗？或者影响就特别大吗？
  &lt;/li&gt;
  &lt;li&gt;
    我们需要权威机构或者国家来维护自己的权益吗？如果是，那么很大概率不适合做成DAPP。
  &lt;/li&gt;
  &lt;li&gt;
    这个系统里有数据造假风险吗？大到必须用中心化的方案解决吗？
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;dapp参考案例和分析&quot;&gt;DAPP参考案例和分析&lt;/h2&gt;

&lt;h3 id=&quot;helium&quot;&gt;Helium&lt;/h3&gt;

介绍：Helium旨在搭建一个全球WIFI网络，通过安装一个符合特定协议的硬件设备到自己家附近，为附近的其他人通过无线网络服务，从而获得回报。采用HNT币结算，迁移到SOL链之后也可以用SOL币结算。

根据指导原则，我们问的问题是：“去中心化是不是他的业务的核心诉求？”。

的确如此，因为如果要走中心化的话，Helium的发起者和全球任何普通老百姓都没有机会来做这件事，几乎所有国家的电信通信都被国家或者大型公司垄断了。

换句话说，Helium不能依赖权威机构来维护自己的权益，因为没有一个国家愿意把这么一个大蛋糕分给别人。

&lt;h3 id=&quot;gainforest&quot;&gt;GainForest&lt;/h3&gt;

介绍：GainForest是几个想保护地球森林的环保爱好者组建的，它给了全球环保人一个公开透明的捐赠网络。

一样的，根据指导原则，我们问的问题是：“去中心化是不是他的业务的核心诉求？”。

这里可能有点拗口，GainForest核心诉求是让全球的环保人士捐钱来保护森林，是不是中心化好像并不重要，毕竟国家也会鼓励这样的事业。

于是我们换个问法：不去中心化，他的模式就没法玩了吗？或者影响就特别大吗？

只要稍微了解过捐赠行业，就会知道这确实是个严重的问题。不管是水滴筹、轻松筹等网络捐赠平台，还是红十字基金会，都被人指责过不透明和暗箱操作。而一旦被外界怀疑，任何一个公益项目在募资的时候都会不那么让人信服，进而无法募集到目标的资金。

或者我们换成第三个问法：这个系统里有数据造假风险吗？大到必须用中心化的方案解决吗？

显然公益行业就是怕这个，机构收了50万，最后用于公益的就20万，对外却说用了40万，这就是拒绝捐款的人们最直接的理由。

所以公益募资最迫切的就是要解决公信问题，而中心化的平台总会被人怀疑他们会为了自己的利益而暗箱操作。这时候做成DAPP，从源头上解决公信问题。

&lt;h3 id=&quot;nft&quot;&gt;NFT&lt;/h3&gt;

介绍：NFT是非同质化代币，具象的说，一个NFT可以是一幅图片、一个视频，或者任何一个东西。所有的NFT网络都在做一件事——证明某个图片、形象和东西是属于某个数字ID的。

根据指导原则，不难分析出NFT一定要做成DAPP大概有以下必要原因：
&lt;ul&gt;
  &lt;li&gt;最具权威性的中心化机构是国家和政府，这两个主体都不太可能出来证明某个物件一定属于某个人的。而普通权威性的公司来做这个事，游戏参与者又不认同，毕竟企业的寿命有限，一旦企业倒闭，损失将不可估量。&lt;/li&gt;
  &lt;li&gt;就算政府来做这样一个中心化的平台，参与者依然可以合理的怀疑，某些能接触系统的人员会为了巨大的利益而修改数据库，甚至删除数据库。&lt;/li&gt;
  &lt;li&gt;另一个因素是，传统的收藏品的赝品很多，甚至赝品被当成真品拍卖都是可能的，普通人无法鉴定，而专业人士也是可以被买通的。而NFT网络的所有参与节点都可以证明某个收藏品是属于某个数字ID的，就算复制多份，大家也只是看到了这个数字形象而已，而并非真的拥有它。拥有它的只有一个数字ID。&lt;/li&gt;
&lt;/ul&gt;

如果不做成去中心化网络，收藏品价值越高，大家越是会有后顾之忧，在这样的担忧之下，没人会斥巨资来拥有一个不稳定的数字资产。这就属于“不中心化，影响就会特别大”的情形。

&lt;h2 id=&quot;总结&quot;&gt;总结&lt;/h2&gt;

DAPP本质上是把数据分布在了数以万计的全球节点上，这样做的好处是不用担心数据被别有用心者轻易修改。但这并不是一种很节能的服务提供形式，并且由于数据需要在整个网络分发，数据及时性也并不优秀。

如果仅仅是数据全球分发和快速访问最新数据，传统的多中心化服务器就可以完美胜任。

DAPP一般使用数字货币进行消费，这样还有一个问题就是资产会受链本位币价格波动而波动，这比国家法币要波动大的多，因此带来的风险也会很高，且从数字货币兑换为法币又是一个繁琐且需要手续费的过程。

所以在决定把自己的业务做成DAPP之前，可以按照以上原则自检一番，如果中心化方案能解决的，或者反过来看去中心化也没有带来太多增益的，还是要保持理性。

&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#区块链的核心意义在于去中心化&quot; id=&quot;markdown-toc-区块链的核心意义在于去中心化&quot;&gt;区块链的核心意义在于去中心化&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#是否做成dapp的指导原则&quot; id=&quot;markdown-toc-是否做成dapp的指导原则&quot;&gt;是否做成DAPP的指导原则&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#dapp参考案例和分析&quot; id=&quot;markdown-toc-dapp参考案例和分析&quot;&gt;DAPP参考案例和分析&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#helium&quot; id=&quot;markdown-toc-helium&quot;&gt;Helium&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#gainforest&quot; id=&quot;markdown-toc-gainforest&quot;&gt;GainForest&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#nft&quot; id=&quot;markdown-toc-nft&quot;&gt;NFT&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#总结&quot; id=&quot;markdown-toc-总结&quot;&gt;总结&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
        <pubDate>Sun, 07 Jan 2024 11:30:00 +0000</pubDate>
        <link>https://tbwork.github.io/2024/01/07/dapp/</link>
        <guid isPermaLink="true">https://tbwork.github.io/2024/01/07/dapp/</guid>
        
        <category>区块链</category>
        
        <category>去中心化</category>
        
        <category>数字货币</category>
        
        
        <category>区块链</category>
        
      </item>
    
      <item>
        <title>DAO组织违法？PSO组织才是未来！</title>
        <description>&lt;h2 id=&quot;什么是dao组织&quot;&gt;什么是DAO组织&lt;/h2&gt;

DAO，全称为”去中心化自治组织”（Decentralized Autonomous Organization），是一种新型的组织形式，它在数字化世界中运作，以一种去中心化的方式进行管理和决策。

想象一下，传统的组织通常有一个中心（比如公司的老板或者领导层），他们负责做出重要的决策，分配资源，雇佣员工等等。但是在DAO中，这个中心被取代了，组织的权力和决策权被分散到了所有成员手中。

DAO使用了区块链技术来实现这种去中心化。区块链是一种分布式的账本技术，记录了所有的交易和操作，确保了透明性和安全性。在一个DAO中，成员可以通过投票来共同决定事务，比如资金的使用、项目的发展方向、新成员的加入等等。

简单来说，DAO就像一个数字化的民主自治国，组织的事务由所有成员共同决定，没有中心权威的干预。这种新型的组织形式可以用于各种领域，比如加密货币项目、开源软件开发、社区组织等等。它带来了更开放、透明和民主的合作方式。

&lt;h2 id=&quot;dao组织的合法性&quot;&gt;DAO组织的合法性&lt;/h2&gt;

中国对DAO（去中心化自治组织）的法律地位尚不明确，存在一定的法律和监管不确定性。我国对于加密货币、区块链技术和相关领域的法律态度也一直在不断发展和调整。

在过去的几年中，政府采取了一些措施来限制和监管加密货币交易、ICO等活动，这可能会影响到DAO组织的合法性。因此国内目前要施行DAO组织还是存在诸多困难的。

&lt;h2 id=&quot;pso组织才是未来趋势&quot;&gt;PSO组织才是未来趋势&lt;/h2&gt;

PSO是超级个体平台（superthem.com）提出的一种新型组织方式，全称为：Platform-based Super individual Organization。它与DAO的理念基本一致，旨在去公司化，去除不合理的剥削层。它是对DAO组织的一种改进。

但是PSO并不鼓励完全的超自由自治，它是基于平台监管和群众监督的一种个体自管理自组织的新型创造方式。超级个体入驻了PSO平台后，受到平台和平台用户的监管，所有交易可追溯，并且会进行实名认证，这能保证组织不会成为违法行为的培养皿。个体的服务交易不像货币交易那样无需为售后担忧，往往服务交易达成后的一个月甚至更长的时间客户都有可能会发现新的问题，这就需要有一个担保机构来保证交易参与者不会为了快速获得利益而诓骗其他交易者。

另外，基于区块链的DAO组织也并不高效，区块链的本质是分布式记账，它的理论基础是“社群不可信”，因此需要通过技术手段来实现共识可信算法。然而其带来的存储损耗也是非常大的，它需要大部分节点都存储与自己无关的大量交易信息。由于担忧信任问题，从而每个人都记住所有人的信息，这本身就是一种内耗。像极了由于担心身边人有一天会跟自己打官司，所以刻意记住大家说的每一句话一样。反之，只要为社群提供一种可信的机制（即平台），那么整个组织就能免去很多不必要的此类内耗。

&lt;h2 id=&quot;传统服务型公司组织的弊端&quot;&gt;传统服务型公司组织的弊端&lt;/h2&gt;

首先，对于普通创业者来说，开公司是一个非常笨重且高成本的行为。如今的用人成本之高，劝退了无数怀揣梦想的年轻人。一旦招募了员工，不管经济形势如何，有没有盈利，薪资都得定期发放，弄不好还会吃官司，而且几乎基本不可能赢。

另外，招聘的成本也越来越高，随着大厂对人才价格的哄抬，这无形中又给普通人创业设立了一道门槛。好的人才天价，普通的人才也并不便宜。创业本来就是一群志同道合的年轻人在一起不计回报去创造，现在则完全变味道了。人才上来就问：有没有年终奖，月薪多少，有没有加班补贴等等。

但这也不能怪人才，高房价和高负债才是根因，年轻人一旦贷款买了房子，每个月的还贷压力就会非常之大。一线城市中不乏资产几百万的中产阶级，但是他们绝大多数都是房奴，就算跳槽也舍不得休息一个月再找工作。毕竟银行是不会允许大家这个月有钱就还，没钱就不还的。这些压力的最终承担者就是无数的民营企业家。

正因为要付出非常大的代价，企业家在好不容易盈利之后也选择变成了资本家。从此以榨取工作者的剩余劳动价值为目标，并且不愿意与工作者分享股权和利润。就算给期权也是象征性的给一点。

以上就是当下公司制度下国民生产关系最真实的样子。

&lt;h2 id=&quot;pso让创造回归本质&quot;&gt;PSO让创造回归本质&lt;/h2&gt;

当下来看，PSO最大的敌人就是高房价，因为高房价，很多人无法安居，很多“有”居的人也只是房奴而已，根本无法奢求“自由”，更别提自己的工作是否如愿了。要想打破高房价的奴役和堵截，PSO必须要拥抱远程工作，远程可以让住房问题得以解决。只要房价合理了，人人都能安居了，人人也自然会乐业。工作者负债没了，便会真正开始思考并选择自己喜欢的事业去做，创业的人也会多起来。

PSO中的超级个体都具备一定的抗风险能力，早期他们大多以大城市返乡人才组成。回到老家的他们生活成本低，房价低，因此对收入的要求也会相应降低。从而他们选择工作和服务对象的动机也更加纯粹，他们会选择自己感兴趣的领域去深耕，利用自己的专业知识为客户去创造价值，同时也实现自身的价值。他们更愿意选择志同道合的人一起工作，为同一个目标去奋斗。

&lt;h2 id=&quot;pso对现有公司的影响&quot;&gt;PSO对现有公司的影响&lt;/h2&gt;

当前阶段，PSO主要所革命的对象是中介转包型的公司，即那些本身自己没有核心产品，只是通过搭建完整的销售体系，接单然后“转包”给自己的员工去做的机构。这样的公司包括中小型的广告公司、代运营公司、软件工作室等。这些公司会直接榨取一线员工劳动的剩余价值，其自身并不提供任何实质的生产价值。

工作室或者小型转包公司的存在只会增加其他实体企业、自主产品企业的成本。他们接的单子越多越好，有时候突然单子多了起来，人员又不可能很快的招聘到位，怎么办？退款是不可能的，只能降低客户服务质量来实现。

而在PSO平台模式下，客户企业跳过工作室，直接与工作者聊。对于一个超级个体承接不了的项目，可以依托平台能力快速组成一个临时团队为客户服务。他们每个人都是直接劳动者和受益者，没有中间商赚差价。工作室老板未来也可以成为一名超级个体，提供项目组织和管理等服务，拿取属于自己的应得收入，这样风险也会小很多，但这个收入相比开公司赚的就合理多了，因为这是他自身劳动所得，而不是之前的剥削所得。

未来PSO平台将诞生大量成功的自主产品型公司，他们的用工成本极低，随时欢迎志同道合的人加入，也不惧怕有想法的人离开。通过保密协议、竞业协议和股权分配协议，任何创业者都将可以以极低的成本去实现自己的想法。而成功的超级个体往往手握多家公司的股票、分红协议或期权，自己的奋斗和坚持可以让自己在40岁前就实现自由的生活，同时也把机会让给更多后来的年轻人。

&lt;h2 id=&quot;pso在圆领超级个体的实践&quot;&gt;PSO在圆领超级个体的实践&lt;/h2&gt;

三年来，通过雇佣圆领超级个体成功的公司案例已经有几十例。其中还有正在筹备上市的，另外像TradeX、蓝盒子这些小有名气的国内外企业也正在通过圆领超级个体从PSO革命中受益。

最近有一款令我痴迷的口语类AI陪练APP（SpeakGuru），最后发现竟然也是我们的一位客户通过雇佣十几个超级个体同学在几个月内做出来的，从设计到实现都非常的专业。相信如果客户是从0到1搭建一个产研团队来做的话，成本至少是现在的3倍有余。

这是在知乎上看到的一个大二学生发的帖子，其中有一段话代表了新一代年轻人对工作和生活的态度：

&lt;img src=&quot;/image/pso/new_young.jpeg&quot; alt=&quot;图1&quot; /&gt;

其实我个人最喜欢的工作形式就是那种没有固定时间的，想做的就去做，不想干的时候去歇个一两个月也不会影响后续重新工作的那种。

可能会有人说这样的孩子未来很难成就事业，我们认为则不然。这才是一种更加先进的生产关系。996玩命式工作带来的是更加严重的内卷、剥削和财富差距，越来越多优秀的年轻人都专注在挣钱还房贷上了，认真做创新、做价值的人则越来越少。等到他们奋斗获得了好地段学区房的时候，他们最富有创造性的年华也逝去了。

做程序员的同学都知道，优秀的底层开源框架几乎全是老外写的。中国优秀的程序员虽然也很多，但是他们的脑力运算都花在了如何升职加薪上了，毕竟上层应用开发是最容易获得成果的。

所以，你准备什么时候上车？

&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#什么是dao组织&quot; id=&quot;markdown-toc-什么是dao组织&quot;&gt;什么是DAO组织&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#dao组织的合法性&quot; id=&quot;markdown-toc-dao组织的合法性&quot;&gt;DAO组织的合法性&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#pso组织才是未来趋势&quot; id=&quot;markdown-toc-pso组织才是未来趋势&quot;&gt;PSO组织才是未来趋势&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#传统服务型公司组织的弊端&quot; id=&quot;markdown-toc-传统服务型公司组织的弊端&quot;&gt;传统服务型公司组织的弊端&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#pso让创造回归本质&quot; id=&quot;markdown-toc-pso让创造回归本质&quot;&gt;PSO让创造回归本质&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#pso对现有公司的影响&quot; id=&quot;markdown-toc-pso对现有公司的影响&quot;&gt;PSO对现有公司的影响&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#pso在圆领超级个体的实践&quot; id=&quot;markdown-toc-pso在圆领超级个体的实践&quot;&gt;PSO在圆领超级个体的实践&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
        <pubDate>Wed, 09 Aug 2023 03:20:31 +0000</pubDate>
        <link>https://tbwork.github.io/2023/08/09/pso/</link>
        <guid isPermaLink="true">https://tbwork.github.io/2023/08/09/pso/</guid>
        
        <category>远程工作</category>
        
        <category>PSO</category>
        
        
        <category>远程工作</category>
        
        <category>PSO组织</category>
        
      </item>
    
      <item>
        <title>远程已来，还工作以本态</title>
        <description>&lt;h2 id=&quot;1-几则平凡的故事&quot;&gt;1 几则平凡的故事&lt;/h2&gt;

&lt;h3 id=&quot;11-雨天的地铁&quot;&gt;1.1 雨天的地铁&lt;/h3&gt;

2020年09月11日，雨，之前的一个多月都是晴天，挤地铁真的感觉乱糟糟的，仿佛所有人都拖着疲惫的躯体机械式的前行着，这些人大多数应该都跟我一样为外来务工人员。我不知道当时有多少人会想为什么他们要来挤地铁，他们也许已经习以为常了，甚至会为自己起晚了10分钟迟到了而感到十分懊恼。我乘坐的地铁线路并不是很挤，但下雨天一到，人流量就莫名多了起来，一群密密麻麻的人挤在一起，背上背着包，一只手拿着伞，仅剩的一只手抓住自己力所能及能抓到的最近的一根钢铁，以便给自己在这摇摇晃晃的茫茫人潮中找到一丝的安全感。

&lt;img src=&quot;/image/remote-work/subway.jpg&quot; alt=&quot;图1&quot; /&gt;

&lt;h3 id=&quot;12-破碎的蛋壳&quot;&gt;1.2 破碎的蛋壳&lt;/h3&gt;

王二（化名）是一名工程师，他在上海某银行担任软件工程师，但并无银行编制，一个月的薪资在15K左右，迫于想给女友一个较舒适的居住环境，他咬牙租了蛋壳公寓，年付了3万多，原本故事到这里就结束了——应该是一对小情侣来到上海一起努力奋斗，谋求属于自己的幸福生活。坑爹的蛋壳缺因资金链断裂，要求租客自行无偿退租，否则这些异乡客将会受到房东的驱赶。王二才入住了3个月，只能退了房子再花一笔不小数目的钱再寻住处。当代的年轻人确实承担了太多，他们为了谋求更好的职业发展来到大城市，原本他们的世界里应当只有奋斗前行、积极向上和努力工作，而总有社会上的不良现象给他们原本已经很艰辛的打工路带去新的荆棘。

&lt;img src=&quot;/image/remote-work/danke.png&quot; alt=&quot;图2&quot; /&gt;

&lt;h3 id=&quot;13-陌生的爸爸妈妈&quot;&gt;1.3 陌生的爸爸妈妈&lt;/h3&gt;

随着挂历上的日子离过年越来越近，毛毛的爷爷奶奶提起“爸爸”和“妈妈”的频率高了起来，每当提起这四个字，10岁的毛毛都会下意识的停下手里已经损坏的玩具扭头懵懂看着爷爷奶奶。身处贵州某山区的毛毛的父母常年在大城市打工，只有逢年过大节才能见到爷爷奶奶口中的爸爸妈妈。年幼的毛毛已经不记得父母的样子，但知道那是爱自己的人，所以听到这几个字便会暖意洋洋。据统计[1]，中国目前有6000万以上的留守儿童，每当浏览一张张留守儿童图片时，笔者眼角都会湿润并发自内心的叹息——为何经济发达的现代还有这么多孩子得不到最基本的幸福。

&lt;img src=&quot;/image/remote-work/alone-child.png&quot; alt=&quot;图3&quot; /&gt;

&lt;h3 id=&quot;14-被榨干的家庭&quot;&gt;1.4 被榨干的家庭&lt;/h3&gt;

李强（化名）毕业于国内一所985高校，家庭并不富裕的他决定与成千上万的同龄人一样来到魔都上海谋求一份好工作。专业实力过硬的他一毕业就顺利的加入了某一线互联网企业，8年过去了，几经跳槽，薪资相比同龄人平均水平已是不低。到了成家的年纪，也出于女友父母的压力，李强萌发了购房的想法。最后看中了一套中环百平不到的房子，售价800万，为了凑够250万的首付款，父母把能借的亲戚都借了个遍，欠下了百万余外债。而噩梦才刚刚开始，往后每月的还贷会彻底磨平这个年轻人，他往后的很长时间里都将过着紧巴巴的日子，并且得时刻警惕内卷和排挤，任何一次意外的失业都将给这个家庭以最沉重的打击。本该享福的年迈父母也没好到哪去，为了替儿子分担压力，年过半百依然丝毫不敢松懈的在工厂工作。

&lt;img src=&quot;/image/remote-work/house-price.jpg&quot; alt=&quot;图4&quot; /&gt;

&lt;h2 id=&quot;2-我们为什么要上班&quot;&gt;2 我们为什么要上班&lt;/h2&gt;

可以确定的是，如果每个人都不用上班，上文的故事大概率都不会发生。从呱呱坠地开始往后的每一天，父母就盼着我们未来能有出息，找个好工作，结婚生子，幸福一辈子。找个好工作几乎成了幸福生活的基础，好的工作会带来好的收入，好的收入能保障衣食住行。从另一个层面看，国家和社会要发展，便离不开其人民的辛勤劳动。工作的本质即劳动创造价值，进而获取回报。“上班”在百度百科的解释为[2]：

&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;上班，是工业文明分工之后的产物，由于个人和家庭出现分工，就需要有相同工作任务的人在同一个地点工作，改变了农业文明时期以家庭和个人为独立劳动单位的格局。&lt;/code&gt;

通俗的说上班就是一群人去到一个相同的地方进行劳动，那为何不能在家劳动呢？其实不然，早在农业时代是没有上班的概念的，农业时代的生产资料（田地）大部分都在农民住宅区附近。15世纪前叶西方社会进入了手工工场时期[3]，一开始雇佣主仍然允许工人在家劳动，定期收货和配发薪资。随着手工业的进一步发展，生产资料机械化愈发发达，雇主无法将其配发给每一个手工劳动者，所以开设了一个工场，把工人集中在一起进行劳动，这便是集中式手工工场[4]。工业革命之后，工业社会的生产资料（各种大型机械）更加无法配发给工人，或者有些生产资料出于保护发明也不能随意的交由他人使用，生产资料集中存放的地方也就是大家熟悉的“工厂”。工业时代的人们之所以上班，是因为生产资料在工厂里，人们必须前往工厂才能进行劳动。也是在这样的大背景下，人们形成并习惯了坐班情形下的沟通和协作。可以预见的是，随着工业技术、互联网、AI技术等科技的进一步发展，工业社会也将逐步退出历史舞台，取而代之的是“知识社会”[5]。在以知识、创新为核心的知识社会中，人们仅需的生产资料很可能就只是一台随处可见的计算机设备（电脑、手机等），其他的需要亲力亲为的劳动将会被机器人替代，人们仅负责知识创造和创新。“知识社会”可能尚未来到，但是当下的很大一部分岗位已经是知识型了，以互联网为主的知识创新型行业中，从本质看人们是无必要“上班”的——程序员、编辑、作家所要的就是一台电脑，创作可以发生在家里的书房、客厅的沙发，也可以是巴厘岛的某个海滩，知识创造本身是location-free的。可能是因为被“去厂里上班”影响了太久，很多人都会形成一种惯性的理解——只要是工作，就一定要上班，甚至本能的认为坐班是效率最高的工作形式。其实不然，随着通信技术的日益发展，沟通已经不再受地域限制，如果每个人都具备良好的表达和自管理能力，相信远程工作的效率会更胜一筹！在远程工作的世界里，人们只工作，不上班！

&lt;h2 id=&quot;3-远程工作还人民安居乐业&quot;&gt;3 远程工作还人民安居乐业&lt;/h2&gt;

说利一般都得说弊，而本文并不打算讨论远程工作的弊端。在深入思考和合理展望后，笔者认为远程工作的利远大于弊，日常所能听到的弊端大多是来自“传统坐班”的惯性思维。先忘掉传统坐班那些牵强的“好处”，一起来看看远程工作的好处！

&lt;h3 id=&quot;31-再见通勤&quot;&gt;3.1 再见，通勤&lt;/h3&gt;

从此以后，您再也不用挤入汹涌的人潮，就为抢到地铁里的一个站位；再也不用早饭都不吃，就为了赶上8点的那班公交；再也不用明明感冒了还拖着疲劳的身躯打着伞背着包艰难的前往办公地，就为了不想用掉仅有的几天年假。每天你将多出1-5个小时的通勤时间去做大把自己爱做的事——为自己做一顿精美的早餐、出去跑一圈、或从读一本买来一直未读的书。下了班约上几个同事玩一把DOTA，或者约上好友看一场电影，这些都不再是遥不可及的事（在坐班的世界里，确实遥不可及）。

&lt;h3 id=&quot;32-再见房租&quot;&gt;3.2 再见，房租&lt;/h3&gt;

来一线城市务工的他乡客们，你们不用再承担那催缴比例假还准时的房租了。可笑的是，每月那小几千的房租也只能换来一个破旧的小屋。有太多的工作者，家乡放着装修好的新房不住，来到上海或北京蜗居在20平不到的小房间里，很难想象他们天天压抑在这样的空间里能有什么真正的创新。

&lt;h3 id=&quot;33-再见令人窒息的房贷&quot;&gt;3.3 再见，令人窒息的房贷&lt;/h3&gt;

和房租一样被来一线城市务工的工作者们诟病的是那几乎变态的高房价，如果不买，则一辈子要被房租恶心，如果买，则必将掏空一个家庭一辈子的积蓄，并且后面的日子都将紧巴巴的过着。远程工作的世界里，你需要的是回到自己的三四线城市，酌情用一线城市的待遇为自己买一套像样的住所，盈余部分改善自己和家庭的生活。届时全民都将安居乐业，在一片自己热爱的土地上从事着自己热爱的事业。

&lt;h3 id=&quot;34-爸妈我回来了&quot;&gt;3.4 爸！妈！我回来了！&lt;/h3&gt;

父母用了二十多年光阴和一生的积蓄把我们培养成才，等我们工作赚钱的时候，却远在千里之外的大城市。远程工作是地点自由的，笔者鼓励每个儿子和女儿能回到自己的家乡，和自己所爱的人生活在一起。很可能我们在北上广每月的房租会给整个家庭带来极大的生活改善，为何我们要病态的认为”放下父母的生活质量不管就为拿下北上广的一套鸟窝”是一种成就呢？爸！妈！我们回来了！

&lt;h3 id=&quot;35-对一切都变了&quot;&gt;3.5 对，一切都变了&lt;/h3&gt;

远程工作带来的变化远远不止于个体的幸福，后效的社会正向影响或将让整个人类历史带入更高层次的繁荣阶段。大部分知识型工作者每天将会多出最多5个小时，当一个国家的很大一部分人民都多出了几个小时来思考和创造，这无疑将极大提升整个社会的创造力。人们将会有时间从事感兴趣的活动，生活中的好奇心将有充分的时间去被满足，人们的生活会更加丰富多彩，而多样化的社会往往会激发更加先进的创新，无论从文学和科学方面看都是如此。

另一方面，城市热点现象将成为过去，当每一轮成千上万的优秀应届毕业生都不再涌入大城市而是选择回到自己的家乡的时候，大城市的发展将会延缓，人才资源会均衡的部署在全国各地，造福一方人民；这些优秀的毕业生回到自己的家乡，拿着一二线城市的薪资待遇，会有效的拉动当地经济，正如现在的城市人才吸引政策所描绘的那样，人才所到之地才有可持续的繁荣。随着中产知识分子的回流，家乡的蓝领、服务业从业者也会随着家乡的逐步发展而回流。随着三四线城市的经济发展，优秀人才也不必只为一二线城市的企业服务，各地也必然会涌现出一批优秀的企业，形成正向循环。

&lt;h2 id=&quot;4-总结&quot;&gt;4 总结&lt;/h2&gt;

远程已来，请还工作以本态。当每个人都不再挤破头涌入大城市，每个人都能安居乐业的时候，相信每个有理想的人都会选择一份自己真正热爱的事业，而不仅仅是哪里眼前的回报高就去哪里。进而的，如果一个工作者真正爱自己的事业，还需要去监督和看管他么？远程的世界里不应该有监管和森严的等级制度，取而代之的是自律自驱、开放透明和主人翁精神。远程工作，将加速推动企业组织形态和管理方法的进化，未来的世界属于自由创造！

&lt;h2 id=&quot;5-关于我们&quot;&gt;5 关于我们&lt;/h2&gt;

笔者致力于推动全国范围内的远程工作，所在公司——瓴里网络科技有限公司，亦是为远程而生，我们的使命是“让每个人都能自由的创造”，我们的愿景是“2030年之前，帮助千万工作者安居乐业。成就百万远程企业”。

我们正致力于打造国内最大的远程工作者社区（圆领）和真正服务于远程企业的生态平台，充满了大量的设计和技术挑战。

现面向社会大量招聘各类远程人才，有兴趣发送简历到bobo@lanehub.cn，来信必回！岗位列表：
&lt;ul&gt;
  &lt;li&gt;Java工程师（含高级）&lt;/li&gt;
  &lt;li&gt;后端架构师&lt;/li&gt;
  &lt;li&gt;前端工程师（含高级）&lt;/li&gt;
  &lt;li&gt;前端架构师&lt;/li&gt;
  &lt;li&gt;产品经理&lt;/li&gt;
  &lt;li&gt;人事经理&lt;/li&gt;
  &lt;li&gt;运营&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;6-参考文献&quot;&gt;6 参考文献&lt;/h2&gt;

[1] 留守儿童百度百科。https://baike.baidu.com/item/%E7%95%99%E5%AE%88%E5%84%BF%E7%AB%A5/1968574

[2] 上班。https://baike.baidu.com/item/%E4%B8%8A%E7%8F%AD/79978?fr=aladdin

[3] 工场手工业时期。https://www.docin.com/p-2328224768.html

[4] 工场手工业。https://baike.baidu.com/item/%E5%B7%A5%E5%9C%BA%E6%89%8B%E5%B7%A5%E4%B8%9A/10921007

[5] 知识社会。https://baike.baidu.com/item/%E7%9F%A5%E8%AF%86%E7%A4%BE%E4%BC%9A/5444228

</description>
        <pubDate>Fri, 01 Jan 2021 12:49:32 +0000</pubDate>
        <link>https://tbwork.github.io/2021/01/01/remote-work/</link>
        <guid isPermaLink="true">https://tbwork.github.io/2021/01/01/remote-work/</guid>
        
        <category>远程工作</category>
        
        
        <category>远程工作</category>
        
      </item>
    
      <item>
        <title>大中台的黄粱一梦和复用性设计的繁荣盛世</title>
        <description>&lt;h2 id=&quot;1-背景&quot;&gt;1 背景&lt;/h2&gt;

自从阿里巴巴现任CEO逍遥子在2015年提出”大中台，小前台”战略以来，关于”什么是中台”，可谓是一石激起千层浪，大量文章在描述什么是中台。而不懂的人看完后依旧是云里雾里，我们经常听到一些词：”业务中台”，”技术中台”, “系统中台”等，我相信很多同学都会懵逼。本文为作者眼中对中台的理解，中台可广义可狭义，理解到其本质含义更为重要。不同于其他由非技术人员编写的中台释义，本文会严格考虑系统实现的可操作性，时刻带着这种落地感来诠释中台。也希望通过此文指引更多的企业走向正确的中台之路，而不要被那些花里胡哨的概念误导，最后落到舍本逐末、烂尾收场的尴尬境地。

&lt;h2 id=&quot;2-中台的本质理解&quot;&gt;2 中台的本质理解&lt;/h2&gt;

&lt;h3 id=&quot;21-大中台小前台战略的由来&quot;&gt;2.1 大中台小前台战略的由来&lt;/h3&gt;

最广为流传的故事应当是2015年年中马云参观SuperCell后感慨这家公司单个员工的创造价值为何如此之大——这家创造了年税前利润15亿美元的公司，却只有不到200名员工[1]。SuperCell这家公司可能大家可能没听说过，但它出品的游戏比如《部落冲突》、《卡通农场》、《海岛奇兵》、《皇室战争》和《荒野乱斗》等相信大家多少有所耳闻。这家公司的组织结构也是另类的，传统公司中越是上层，权利也越大，需求、产品定义都是由上至下的，如下图所示：

&lt;img src=&quot;/image/mid-plat/traditional-company-arch.jpeg&quot; alt=&quot;图1&quot; /&gt;

而在SuperCell，CEO权力很小，CEO自称是”世界上权利最小的 CEO“，其实这正是一种睿智，自己反而轻松了，类似老子提出的“无为之治”，老祖宗的很多道理真的是放之天下皆可。先看下SuperCell的组织结构：

&lt;img src=&quot;/image/mid-plat/supercell-company-arch.jpeg&quot; alt=&quot;图2&quot; /&gt;

他们的工作模式是这样的：谁都可以发起新的游戏创意，然后给组织几个人去实施，做出来看看，行不行，火了就进一步推广，风靡一把；火不起来，玩家不活跃，那这个创意立即终止，再来一个新的继续搞。这个想法其实他们不是第一个，很多公司都内部竞争，都有多产品实施。它们的牛逼之处还是在于上线一个游戏竟然只要若干人的小组就可以完成，笔者了解到的大公司中很多互相竞争的项目团队各自都是百人规模，还频繁在招人。SuperCell的快速业务试错模式固然是值得学习的，但支撑这些快速变化的却是背后的那套游戏构建系统。相信很多人，尤其是男生，都会偶尔有个想法：”要是能开发出这样那样玩法的游戏就好了“。现在若是有一个平台，你只需要配置各种事件对应的反馈、游戏的一些设定、建筑的风格等，再配备几个美工，对游戏中的物体进行按需美化，这些操作之后，平台就会给你生成一款全新的符合你设计的游戏，这是多么高效、轻松、低成本的一件事。相信只要熟悉这套系统，谁都可以在极短的时间内，完成一个新游戏的创建。事实证明，SuperCell的这套新游戏研发系统已经炉火纯青了，《皇室战争》和《海岛奇兵》这两个游戏，如果您都玩过，你会发现它们的游戏画风极为相似，本人曾一度以为它们是一款游戏，只是做了APP升级。

就是这么一个逻辑，对前去参观的马老师一行人来说，犹如醍醐灌顶，豁然开朗。做管理做企业的领导们在看到“新”的高效的模式的时候，总是会想着我们公司是不是也可以这么搞？网上流言中台是马老师提出的无从考证，本人所知的情况是逍遥子内发的邮件最先提到了这个概念[2]。根据广泛的理解，前台一般对应着一个具体的商业模式以及配套的用户应用（App、小程序等），对应阿里的中台架构图（3.1部分会提到），前台就是一个个BU业务线。注意，这张图里压根就没有后台。

&lt;blockquote&gt;
  “新”打了引号，是想表明，这种软件通用性的设计其实很早就有了。
&lt;/blockquote&gt;

还有一种推理帝们的说法是，后台对应了面向内部人员的运营配置、前台对应了面向用户的客户端，所以中台就是衔接它两的。笔者想提醒下，这是压根不是技术人员提出来的，当年张建锋接到马老师的中台作业，也纳闷了半天，百思不得其解。高层管理们不会这么理性的技术化的看待前中后台的关系，个人猜测他们的逻辑是，用户看得到的这些叫前台，这之后看不见的所有的支撑平台叫后台，由于考虑到需要直接支撑前台又特别想和技术人反复说的后台区分开，所以搞了一个前无古人，后无来者的叫法——中台，连专业代码二十年的阿里各大技术元老们都涨了见识。笔者看来，在管理层眼中的中台和后台（这里的后台跟技术理解的后台管理系统也不是同一件事）并无差异，只是强调这跟之前看不见的后台是有差异的，他们希望中台这部分能打造成为一个公共后台，而不是竖烟囱式的后台。

说了这么多，总结下本文通用的中台定义：前台的支撑系统，基础设施层之上的通用业务层，具体由通用的业务领域能力和与其对应的后台系统共同组成。画成图的话大概是这样：

&lt;img src=&quot;/image/mid-plat/what-is-mid-plat.png&quot; alt=&quot;&quot; /&gt;

其中前台特有领域和中台领域之间的比例是按前台业务差异性不同而变化的，有些场景下，中台领域可以做的非常厚，厚到前台就剩一个前端应用（APP、小程序、PC站等）；有些场景下，中台可能只能做有限的抽象。笔者的另外一个观点是——中台是一个相对的概念，除了整个集团能谈中台，在各个前台领域中，前台研发团队仍然可以做自己的“小中台”，用于服务自身商业模式下的多变的一类业务产品。这种关系是多级的，本质都是在做复用设计。

&lt;h3 id=&quot;22-超级细胞公司的中台本质&quot;&gt;2.2 超级细胞公司的“中台”本质&lt;/h3&gt;

个人非常欣赏埃隆·马斯克经常提及的“第一性原理”[3]，从本质来思考，SuperCell公司并不是一开始就有一个“大中台、小前台”的战略在指引自己，而是任何一家游戏公司，要想做得好，不完全是追求短期利益，都会走向这条路。事实上，超级细胞自身从来没有公开提出什么“中台”的概念。只从游戏工厂这种产品模式来说，SuperCell也不是第一家这样做的公司，所有玩过暴雪的WarCraft（魔兽争霸）的同学都知道，它不仅仅是一款即时战略游戏，它还是一个游戏制造器，通过创建一个新的地图，配置剧情，任何人都可以很快的上手并创建一个自己的玩法。游久网[4]就是这么一个专门提供不同魔兽争霸地图的网站。虽然看不到超级细胞的游戏创造后台系统，我们可以看看魔兽争霸的游戏编辑器是啥样的：

&lt;img src=&quot;/image/mid-plat/map-build.jpg&quot; alt=&quot;图3&quot; /&gt;

通过任务系统和事件系统，我们还可以定制出各种剧情。为了展示下魔兽地图编辑器（WE）有多变态，以下几幅游戏截图，都是来自于自定义的地图[5]。
&lt;img src=&quot;/image/mid-plat/example-1.jpg&quot; alt=&quot;图4&quot; /&gt;
&lt;img src=&quot;/image/mid-plat/example-2.jpg&quot; alt=&quot;图5&quot; /&gt;
&lt;img src=&quot;/image/mid-plat/example-3.jpg&quot; alt=&quot;图6&quot; /&gt;

单说游戏工厂这种产品或游戏创作模式，暴雪的游戏团队绝对是全球顶尖的。在超级细胞的官网介绍中也曾提到，他们的很多员工都是魔兽世界的铁粉[6]。然而人们关注的往往是成功的对象，暴雪最近几年在手游领域除了炉石传说这种卡牌类的，几乎没出啥游戏。PC游戏做的再好，知名度也很难与全民参与度更高的手游相比。与这些先驱游戏公司类似的，超级细胞的“中台”系统本质也是一个游戏工厂，是游戏行业里的一种高复用性、高度可自定义、高度开放式设计的软件系统。当然了，这个工厂生产的东西可能只是一套虚拟的游戏逻辑，具体的用户端APP还是需要依靠研发团队进一步加工和研发的。

个人猜想，马老师一行人回去之后，对标超级细胞一想，这么大一个公司，每天有那么多想法和创意，每个创意、产品都搞一个五脏俱全的团队去实施那得浪费多少人力成本？要是有一个强大的系统，可以让各种想法和创意快速试错，推向市场、反馈、迭代，行就推广，不行就终止，那该多高效。所以才有了后来的“大中台、小前台”战略，为的是给业务打造快速试错的平台，他们理解的中台实质就是一个业务产品工厂，可以通过“配置大于研发的约定”快速构建业务前台，这对应了超级细胞的各种游戏。

&lt;h3 id=&quot;23-中台本质总结&quot;&gt;2.3 中台本质总结&lt;/h3&gt;

为了更好的阐述和帮助读者理解下文笔者的意图，先总结下对中台的一些理解：
&lt;ul&gt;
  &lt;li&gt;&lt;strong&gt;中台的意图&lt;/strong&gt;：让业务更好的进行创新、试错，同时大幅降低新业务研发成本。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;中台的理论基础&lt;/strong&gt;：前台只是一层皮（这层皮也不仅仅是前端，还可以包括后面的前台领域系统），基础设施只是一套没血肉的骨架，位于中间的看不见的血肉才是软件系统的核心，如果这些血肉每次都要重建，那么将严重阻碍新业务创新、试错的速度。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;中台的方法论&lt;/strong&gt;：和平台方法论并无差异——抽象通用能力+开放设计，这两者比例多大，不好说，这里也不想耍流氓那样用个二八定律去糊弄大家，相信不同的业务场景这个比例多少会有些不同。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;中台的本质&lt;/strong&gt;：四个字——系统复用。复用也分层次，也有复用程度之分，通过抽象出各种配置来支撑定制化这件事的本质也是复用——复用配置系统。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;中台的实施原则&lt;/strong&gt;：专注领域复用能力建设、配置大于研发。这个点看似很简单，但是极具艺术性，配置如何做到化繁为简很关键，如果发现配置复杂度比研发还大，那就瞎了。&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;3-阿里大中台小前台战略的成与败&quot;&gt;3 阿里“大中台、小前台”战略的成与败&lt;/h2&gt;

&lt;h3 id=&quot;31-阿里中台建设之路&quot;&gt;3.1 阿里中台建设之路&lt;/h3&gt;

2016 ATF阿里技术论坛于4月15日在清华大学举办，主旨是阐述阿里对世界创新做出的贡献。会上阿里业务平台事业部&amp;amp;淘宝基础平台技术部负责人玄难阐释了淘宝经历13年的发展中，业务平台从零到有，同时又逐步演进为业务中台[7]。下面是个人梳理的可能与阿里中台战略提出有关的一个时间线[8]:
&lt;ol&gt;
  &lt;li&gt;2003年淘宝事业部成立，推进以淘宝为中心的电商系统。&lt;/li&gt;
  &lt;li&gt;2008年，从淘宝事业部中抽出了一拨人，成立了天猫（最初期也叫淘宝商城）。天猫瞬间变火，业务话语权飙升，于是晋升成了天猫事业部，与淘宝事业部并驾齐驱。但是由于主要的技术团队都还是淘宝的，所以你懂的，很多公司毛病之一——屁股意识太强，所以天猫的需求优先级总是比不过淘宝自身的。天猫业务团队自然就不爽了。另外，到这个时候，天猫和淘宝的大部分业务系统都是各自建设的，但都是由淘系研发团队负责。&lt;/li&gt;
  &lt;li&gt;2009年，共享业务事业部应运而生。领导层发现上述的问题后，决定成立一个与淘宝事业部、天猫事业部平级的事业部，用来处理他们的公共业务。这么看起来似乎很棒，但却带来了另一个问题，共享业务事业部自身没有前台业务，自然话语权比较小，所以逐渐演变成一个两头受气、吃力不讨好的角色。纵使研发天天加班，也填满不了铺天盖地的需求。&lt;/li&gt;
  &lt;li&gt;2010年，基于共享业务搭建的聚划算前台取得了喜人的成绩，从此说话腰杆子都直了。当时集团就要求1688、淘宝、天猫要想上聚划算，必须通过共享业务事业部。目前，阿里集团超过25个业务单元（如淘宝、天猫、聚划算、去啊等）都是基于这个共享业务事业部上构建的。整体架构如下图所示：
&lt;img src=&quot;/image/mid-plat/ali-common-plat-arch.jpg&quot; alt=&quot;图7&quot; /&gt;&lt;/li&gt;
  &lt;li&gt;2015年年底，集团“大中台，小前台”战略正式启用，逍遥子张勇在邮件里写道：“构建符合DT时代的更创新灵活的‘大中台、小前台’组织机制和业务机制：作为前台的一线业务会更敏捷，更快速适应瞬息万变的市场；中台将集合整个集团的运营数据能力、产品技术能力，对各前台业务形成强力支撑”。尝到了共享业务事业部的甜头后，加上前往超级细胞获得的灵感，集团大胆的走出了激进的一步——构建集团中台，纳入更多的BU。此时的整个中台的大致结构如下：
&lt;img src=&quot;/image/mid-plat/big-mid-small-app.jpg&quot; alt=&quot;图8&quot; /&gt;
其中玄难负责业务中台事业群，致力于构建和推行整个集团的业务中台。&lt;/li&gt;
  &lt;li&gt;2019年，玄难离职创业，方向为电商中台。坊间一个比较靠谱的说法是：2015年阿里制订了一个15~18的三年中台战略，但到19年还没有任何建树，所以中台大将玄难不得不引咎辞职。&lt;/li&gt;
  &lt;li&gt;2019年阿里组织架构又进行了调整[9]，如下图所示，中台的影子已悄然不见，取而代之的是出现了很多能力型BU和基础基建，这标志着中台回归本质化——复用，既然是复用，自然是被复用的能力型BU躺在下面，面客业务性BU在上面各自发展。
&lt;img src=&quot;/image/mid-plat/ali-org-arch-2019.jpg&quot; alt=&quot;图9&quot; /&gt;&lt;/li&gt;
&lt;/ol&gt;

至今，官方和小道消息都没有具体中台有没有做成的消息，说没有做成吧，淘系电商业务平台（也可以叫中台）确实支撑了好多BU。但是支撑归支撑，要是中台做不大，前台做不小，可能还是达不到管理层的目标。笔者猜测，由于管理层过度的理想化，导致技术实施时困难重重，毕竟复用性并不是想做多大就可以做多大的，支撑的业务模式越多，抽象出来的通用复用性就越底层。这就达不到小前台的效果，前台还是需要一定规模的研发团队，事实证明，目前阿里的各个BU仍然各自都有着大量的研发团队。

&lt;h3 id=&quot;32-阿里中台战略败点分析&quot;&gt;3.2 阿里中台战略败点分析&lt;/h3&gt;

该部分没有什么参考文献，全部为个人的观点。笔者做软件设计和研发已有12年，作为一名架构师和码农，个人最怕的就是自己因为害怕走出舒适区而陷入“极端陷阱”。这是一个笔者自己发现和定义的现象：很多时候，绝大多数人会认定一个死理，难以自拔，当大脑好不容易发现了某种理解可行时，不想再接受更多的反例，不愿意再去用第一性原则慢慢推导，个人认为这也是一种不想走出舒适区的表现。陷入极端陷阱后引发的问题是——你以高层领导的身份急着去拍了一个方案，实际上还有很多细节没想明白就在公司大规模的去推行，这样大概率的结果就是烂尾。以下是按个人理解总结的阿里“全局大中台、小前台”战略的两个致命问题。

&lt;blockquote&gt;
  注：本节仅代表个人思考，不能作为事实依据。
&lt;/blockquote&gt;

&lt;strong&gt;(1) 中台应当分门别类，因地制宜，全局中台并不适合大集团&lt;/strong&gt;

阿里集团业务繁杂度远高于超级细胞，中台范围应当细化，不适全局中台。治理小区和治理国家固然有一些类似的点和方法论，但是问题规模变大后，很多小规模下的方法也会变得不再适用，这是一个广泛被认可的观点。超级细胞的业务范围很专一，就是手游，所以它可以很容易就做成游戏工厂。放到阿里这样的大集团，业务种类繁杂，性质大相径庭，何必强融？像淘宝、一淘、天猫，这些其实换汤不换药，那么即便没有中台战略，架构师也知道很多业务逻辑可以复用，要说阿里架构师没有超级细胞的架构师懂？怎么可能。文献[7]中提到的第三阶段其实已经在考虑通过搭建业务平台来建设通用业务能力。而管理层想通过打造一个统一的万能中台来支撑所有集团业务前台（参考图8），是未经深度思考的表现，从超级细胞小公司到阿里大集团，业务复杂度规模急剧增大，怎么能照搬模式呢。正如没有一个架构师可以在新问题上做出百分之一百与实际匹配的架构一样，也不会有一个统一的万能中台能在保证开闭原则的基础上适配所有业务。

总结来说，阿里集团业务繁杂，不能把BU当做前台来构建大中台，每个BU就是一个独立的公司，有着自己独立的业务，根本“小”不了。而为各个BU做的那些通用的东西也是具有局限性的，只能帮助上层BU节省部分研发成本。过度贪求高度复用，会陷入某种陷阱——把不该抽象的东西硬是抽象到了一起，结果就是系统的复杂度并没有降低，而是将这种复杂度从多个地方集中到了一个地方。因此，管理层想要的“全集团大中台、小前台”，是一种理想主义，注定难以实现。

&lt;strong&gt;(2) 全局中台带来的新问题——依赖单点和热点&lt;/strong&gt;

按上文的理解，中台战略实际上更大意义在于提醒所有BU，要尽量建造可以复用的通用能力，为BU业务创新营造一个高效低成本的环境。而如果我们把一家大集团的所有主要业务系统都放到一个事业部去管理，就会产生一个新的问题——单点，甚至会演变为热点问题。每个BU甚至业务线都各自有KPI，如果某个BU发现中台无法支撑自己的场景（因为总会有没考虑的情况），那么势必要求中台团队做支撑，需求一多，还得排队，这和BU寻求快速迭代和业务修正节奏是背道而驰的。所以复用能力涉及的业务范围越大，单点问题就越是严重，单点变热点的概率也就越大。即便中台事业部做的再大，哪怕为每个BU都搞一个小团队去支持，由于所背的KPI和汇报关系并不在所支撑的BU，实践起来总是会存在信息断层。

合理的复用是不会产生热点的，因为正确的抽象是稳定的，其设计思路会无差别的对待所有用户，要么一个用户都没法用，要么所有用户都可以用（无故障的情况下）。就好比数据库一样，任何一款数据库都不会关注数据的业务属性，电商的数据能存，金融的数据必然也能存。引入数据库就是一种数据存取能力复用——当然数据库属于基础设施，复用性是必要的。

&lt;h3 id=&quot;33-阿里中台战略的成功之处&quot;&gt;3.3 阿里中台战略的成功之处&lt;/h3&gt;

时至今日，中台的理念已经深入所有互联网人的心，阿里集团各个BU也在打着自己的中台算盘。全局大中台虽未建成，单各个事业部都开始在研发中试着使用中台思维去思考自己的研发体系。中台的理念一定是没错的，只是要因地制宜，切忌一刀切。早期，大家只会思考基础设施的复用性，产品如各种中间件等，现在大家开始关心另外一个问题了——这个业务能不能做成一个通用能力；又或者，会先问问其他同学——集团是不是有这样的业务能力可以复用过来？这就是一种良性的影响。

中台，未必要大。前台，未必就小。能避免低水平重复性劳动的研发体系，就是可以被称为优秀的研发模式。

&lt;h2 id=&quot;4-企业如何建设适合自己的中台&quot;&gt;4. 企业如何建设适合自己的中台&lt;/h2&gt;

&lt;h3 id=&quot;41-中台建设的通用步骤&quot;&gt;4.1 中台建设的通用步骤&lt;/h3&gt;

&lt;strong&gt;(1) 定义需要快速变化、试错的前台业务（业务线、产品线）&lt;/strong&gt;

如果您都无法清晰的定义自己的业务线，那么可以先内部脑暴一下。先基于现有的业务线讨论，再继续讨论未来可能发展的业务线。

&lt;strong&gt;(2) 领域分析和模块划分&lt;/strong&gt;

架构师在充分了解了每个业务线后，梳理出每个业务线所需要的业务领域块。这对架构师的要求很高，纯粹的业务架构师可能无法胜任，但是可以参与讨论。 纯业务架构师可能对研发细节欠缺考虑，从而做出形而上无法落地的复用设计。

&lt;strong&gt;(3) 识别业务线共性并归类&lt;/strong&gt;

架构师进行前台业务线归类。通过上文的讨论我们知道中台的本质是复用性设计，那么业务线分类就是把可以大程度进行复用业务逻辑的业务线放到一起。这部分需要资深架构师参与，毕竟这很大程度上是一个经验活。有些不该放到一类的业务线应当分开，比如金融业务和电商业务大相径庭，硬是搞一个团队同时维护两套系统，甚至揉在一个系统里，结果是不会太好的。

&lt;strong&gt;(4) 画出领域模块（能力）对齐图&lt;/strong&gt;

由2、3步骤可以画出一个各业务线所需的领域能力图。把名字相同(或者类似)的领域能力对齐，如下图所示大致的内容为：
&lt;img src=&quot;/image/mid-plat/domain-analysis-map.png&quot; alt=&quot;图10&quot; /&gt;

&lt;blockquote&gt;
  需要注意，图中的每个域不代表只有一个服务，服务数量可以是多个。
&lt;/blockquote&gt;

先申明下，该图只是提供一种参考，着重去说明复用设计的通用步骤，不具备实际的参考意义，各企业应当结合自身的具体现状具体分析。图中每一列相同的颜色代表它们可以做成一套系统，给各个前台复用。从图中我们可以看出以下关键信息：
&lt;ul&gt;
  &lt;li&gt;一般来说相同业务类别相同的他们的领域划分也比较类似，但也存在反例，比如本地生活中的外卖和到店O2O，可能在商品、营销上有着很大的差异。&lt;/li&gt;
  &lt;li&gt;用户中心一般不带有具体的业务信息，这部分是可以做成全局统一的，也方便统计用户画像。当然了，各个业务线除了对接这个统一的用户中心外，还是要各自记录一些跟自身业务相关的用户信息，比如金融用户的征信信息等，这种信息可能还需要由另外的系统来承载——比如征信中心。&lt;/li&gt;
  &lt;li&gt;同样的商家结算，一般都是B2B之间的资金往来，业务不同仅仅影响的是交易凭证的描述不同，其他的结算方式等完全可以复用。&lt;/li&gt;
  &lt;li&gt;商品中心，看起来各个业务都有商品中心，但是各个业务线的商品结构可能存在差异，比如金融和传统电商的商品中心，其实现逻辑应当是不一样的。当然，硬要把金融产品标上价格，打上SKU去传统电商前台去卖，也是可以的，只是这种方式带来的问题需要事先想好怎么克服，例如，谁来配置这些SKU，谁来进行商品售后等等。&lt;/li&gt;
  &lt;li&gt;一般涉及货物差异性的业务，都会用到评价中心，这是对商户货物品质的一种用户反馈。而在金融行业的贷款业务看来一般不会对不同的资金提供方去做评价，不排除其他业务会有，比如基金业务等。&lt;/li&gt;
  &lt;li&gt;而有些领域是业务特有的，比如电商经常需要用到比价中心，它负责对手商品价格的抓取和匹配等。&lt;/li&gt;
&lt;/ul&gt;

&lt;strong&gt;(5) 严格遵循开闭原则，从底至上的去实施&lt;/strong&gt;

针对我们上文找出的存在复用可能性的领域（每一列里颜色相同的领域块），架构师需要识别出其边界和专注解决的问题，最后安排不同的产研团队去实施。各个领域块的研发团队在实施时应当尽可能的抽象公共业务逻辑，并且将无法通用的环节做成开放式的。只要按照这个思想创建的系统，即便没有配置后台，上层业务系统对接也是极其轻松的。这里推荐另一篇笔者的文章&lt;a href=&quot;/_posts/2018-05-22-layed-dev-arch.md&quot;&gt;浅谈微服务体系中的分层设计和领域划分&lt;/a&gt;，它讲述的就是一种搭建通用大后端的系统架构，从柔性的定义来看，这也是中台——它可以支撑新业务应用快速研发。在完成了通用能力的搭建后，我们还可以为每个通用能力去构建配置后台，这样可以更快的给前台应用研发提速，配置优于研发带来的好处就是不需要走研发流程就可以完成一定的定制逻辑。

</description>
        <pubDate>Sun, 02 Aug 2020 11:43:18 +0000</pubDate>
        <link>https://tbwork.github.io/2020/08/02/what-is-mid-platform/</link>
        <guid isPermaLink="true">https://tbwork.github.io/2020/08/02/what-is-mid-platform/</guid>
        
        <category>中台建设</category>
        
        <category>产品中台</category>
        
        <category>中台战略</category>
        
        
        <category>行业战略</category>
        
      </item>
    
      <item>
        <title>浅谈双十一背后的支付宝LDC架构和其CAP分析</title>
        <description>&lt;h2 id=&quot;1-背景&quot;&gt;1 背景&lt;/h2&gt;

&lt;blockquote&gt;
  本文曾获阿里内网ATA“峰云之巅”奖。未经允许，不得转载。本文曾被大量转载和修改文章标题，给本人带来了极大的伤害。
&lt;/blockquote&gt;

一年一度的双十一又要来了，自2008年双十一以来，在每年双十一超大规模流量的冲击上，蚂蚁金服都会不断突破现有技术的极限。2010年双11的支付峰值为2万笔/分钟，全天1280万笔支付，这个数字到2017双11时变为了25.6万笔/秒，全天14.8亿笔。在如此之大的支付TPS背后除了削峰等锦上添花的应用级优化，最解渴最实质的招数当数基于分库分表的单元化了，蚂蚁技术称之为LDC（逻辑数据中心）。本文不打算讨论具体到代码级的分析，而是尝试用最简单的描述来说明其中最大快人心的原理。我想关心分布式系统设计的人都曾被下面这些问题所困扰过：
&lt;ul&gt;
  &lt;li&gt;支付宝海量支付背后最解渴的设计是啥？换句话说，实现支付宝高TPS的最关键的设计是啥？&lt;/li&gt;
  &lt;li&gt;LDC是啥？LDC怎么实现异地多活和异地灾备的？&lt;/li&gt;
  &lt;li&gt;CAP魔咒到底是啥？P到底怎么理解？&lt;/li&gt;
  &lt;li&gt;什么是脑裂？跟CAP又是啥关系？&lt;/li&gt;
  &lt;li&gt;什么是PAXOS，什么是Quorum法定数量，它们解决了啥问题？&lt;/li&gt;
  &lt;li&gt;PAXOS和CAP啥关系？PAXOS可以逃脱CAP魔咒么？&lt;/li&gt;
  &lt;li&gt;Oceanbase能逃脱CAP魔咒么？&lt;/li&gt;
&lt;/ul&gt;

如果你对这些感兴趣，不妨看一场赤裸裸的论述，拒绝使用晦涩难懂的词汇，直面最本质的逻辑。

&lt;blockquote&gt;
  本文提及的所有关于支付宝和蚂蚁的技术点均为网络采集，未经亲自核实，请谨慎参考。如有涉及关键技术泄露请指明具体细节，并提供证据，比如到底是哪个点侵害了您的哪个权益。尤其是支付宝的公关和法务同学，不要听风就是雨，本文曾被大量转载和修改名称，尤其会携带一些“大厂揭秘”等具有误导性的词汇，请保持理性阅读，过脑分析。按照个人的理解，本文不涉及任何关键技术细节，也不会给贵司带来任何损失和负面作用。
&lt;/blockquote&gt;

&lt;h2 id=&quot;2-ldc和单元化&quot;&gt;2 LDC和单元化&lt;/h2&gt;

LDC（logic data center)是相对于传统的（Internet Data Center-IDC）提出的，逻辑数据中心所表达的中心思想是无论物理结构如何的分布，整个数据中心在逻辑上是协同和统一的。这句话暗含的是强大的体系设计，分布式系统的挑战就在于整体协同工作（可用性，分区容忍性）和统一（一致性）。

单元化是大型互联网系统的必然选择趋势，举个最最通俗的例子来说明单元化。我们总是说TPS很难提升，确实任何一家互联网（比如淘宝、携程、新浪）它的交易TPS顶多以十万计量（平均水平），很难往上串了，因为数据库存储层瓶颈的存在再多水平扩展的服务器都无法绕开这个瓶颈，而从整个互联网的视角看，全世界电商的交易TPS可以轻松上亿。这个例子带给我们一些思考：为啥几家互联网的TPS之和可以那么大，服务的用户数规模也极为吓人，而单个互联网的TPS却很难提升？究其本质，每家互联网都是一个独立的大型单元，他们各自服务自己的用户互不干扰。这就是单元化的基本特性，任何一家互联网公司，其想要成倍的扩大自己系统的服务能力，都必然会走向单元化之路，它的本质是分治，我们把广大的用户分为若干部分，同时把系统复制多份，每一份都独立部署，每一份系统都服务特定的一群用户，以淘宝举例，这样之后，就会有很多个淘宝系统分别为不同的用户服务，每个淘宝系统都做到十万TPS的话，N个这样的系统就可以轻松做到N*十万的TPS了。

LDC实现的关键就在于单元化系统架构设计，所以据说在蚂蚁金服内部，LDC和单元化是不分家的，这也是很多同学比较困扰的地方，看似没啥关系，实则是单元化体系设计成就了LDC。

&lt;blockquote&gt;
  小结：分库分表解决的最大痛点是数据库单点瓶颈，这个瓶颈的产生是由现代二进制数据存储体系决定的（即I/O速度）。单元化只是分库分表后系统部署的一种方式，这种部署模式在灾备方面也发挥了极大的优势。
&lt;/blockquote&gt;

&lt;h3 id=&quot;21-系统架构演化史&quot;&gt;2.1 系统架构演化史&lt;/h3&gt;

几乎任何规模的互联网公司，都有自己的系统架构迭代和更新，大致的演化路径都大同小异。最早一般为了业务快速上线，所有功能都会放到一个应用里，系统架构如图1所示。

&lt;img src=&quot;/image/ant-ldc-arch/monolithic-arch.jpg&quot; alt=&quot;单应用单服务器架构&quot; /&gt;

这样的架构显然是有问题的，单机有着明显的单点效应，单机的容量和性能都是很局限的，而使用中小型机会带来大量的浪费。
随着业务发展，这个矛盾逐渐转变为主要矛盾，因此工程师们采用了以下架构。

&lt;img src=&quot;/image/ant-ldc-arch/distributed-arch.jpg&quot; alt=&quot;单应用多服务器单数据库架构&quot; /&gt;

通过对应用进行水平扩展可以大幅度提高服务器容量，这时候应用代码还是一份，里面五脏俱全，只是应用代码运行在多个服务器实例上。这也是整个公司第一次触碰到分布式，它的理论基础是将多个微机的计算能力团结起来，其效果可以完胜同等价格的中小型机器。随着业务进一步发展，用量到达了百万级，慢慢的大家发现，应用服务器CPU都很正常了，但是还是有很多慢请求，究其原因，是因为单点数据库带来了性能瓶颈。于是程序员们决定使用主从结构的数据库集群，如下图所示。

&lt;img src=&quot;/image/ant-ldc-arch/distributed-arch-with-master-slave-db.jpg&quot; alt=&quot;单应用多服务器数据库集群架构&quot; /&gt;

其中大部分读操作可以直接访问从库，从而减轻主库的压力。然而这种方式还是无法解决写瓶颈，写依旧需要主库来处理，当业务量量级再次增高时，写已经变成刻不容缓的待处理瓶颈。这时候，分库分表方案出现了。

&lt;img src=&quot;/image/ant-ldc-arch/distributed-sharding-arch.jpg&quot; alt=&quot;分库分表的分布式服务架构&quot; /&gt;

分库分表不仅可以对相同的库进行更细的业务拆分，还可以进行对同一张表进行拆分，对表进行拆分的方式叫做水平拆分。原本在同一个库中不同功能表拆分后放到不同的数据库中，这种方式对应的是垂直拆分（按照业务功能进行拆分），此时一般还对应了微服务化。分库分表往往按照用户ID进行散列，不同用户的数据访问请求会在固定的不同数据库实例上进行处理，这种方法做到极致基本能支撑TPS在万级甚至更高的访问量了。然而这种模式下需要每个扩展出的应用都连接所有的数据库实例以保证任意用户的请求在本应用都能进行处理，随着应用扩展的越多，每个数据库实例的连接数也成倍增长，而数据库服务器的连接数量一般是恒定的，因此无法跟着可以无限扩容的应用服务实例增长而同比增长，这种机制是出于对数据库的保护而设计的。事实上即便数据库连接池可以无限增长，应用服务也会花费大量的性能消耗在维护与每个分库的数据库连接池上。比如在16个分库200台水平扩展应用的情况下，若每个应用与数据库的连接池在100个，那么每台应用上的数据库连接数量将高达1600个，每台数据库服务实例上维护的连接数量达20000个。虽然对于任意一台数据库来说不代表同时会有20000个连接在传输数据，但由于系统实际运行时的各种不可预期的复杂调用（比如原先估计同时最多只有200个连接在读写数据——根据数据库服务的容量进行合理计算得出，实际上一旦将最大连接数设置为20000个连接，同时读写的连接数超过200会变得非常常见）和请求流转以及数据库服务器中连接调度的性能消耗，这20000个始终保持存活的连接将逐步成为数据库访问的瓶颈，从而影响整个系统。

&lt;blockquote&gt;
  Mysql等数据库的主流用法中都是在数据访问期间独占连接，而不是像HTTP2.0那样允许多路复用的纯异步访问，这是很多关系型数据库的设计原则。
&lt;/blockquote&gt;

从本质上看，这种模式的资源隔离性还不够彻底，总会存在资源间互相污染的情况，这些污染最终会变现为系统的急剧熵增。要彻底让资源进行隔离，就需要按照某种规则将网络访问用户进行分流，让一套服务和数据库为某个特定群体进行服务——就像每个电商平台一样，这样一来凡是来自这个用户的所有请求都会由其对应的应用服务和数据库实例来处理，而不会影响其他的服务和数据库。这样带来另外一个变化就是识别用户分库的逻辑需要往上层移动——从数据库层向上移动到路由网关层。当网关识别到A用户时通过散列算法将其分配到对应的应用服务器(Server-A)，最后数据持久化到对应的数据库实例DB-1，因此Server-A也不再需要链接其他的数据库实例了，如此一个单元化的雏形就诞生了。

&lt;img src=&quot;/image/ant-ldc-arch/unitize-arch.jpg&quot; alt=&quot;单元化分布式服务架构&quot; /&gt;

如上图所示，但我们把整套系统打包为单元化时，每一类的数据从进单元开始就注定在这个单元被消化，由于这种彻底的隔离性，整个单元可以轻松的部署到任意机房而依然能保证逻辑上的统一。下图为一个三地五机房的部署方式。

&lt;img src=&quot;/image/ant-ldc-arch/ant-3-city-5-center-arch.jpg&quot; alt=&quot;三地五中心架构&quot; /&gt;

&lt;h3 id=&quot;22-支付宝单元化架构实践&quot;&gt;2.2 支付宝单元化架构实践&lt;/h3&gt;

蚂蚁支付宝应该是国内最大的支付工具，其在双十一等活动日当日的支付TPS可达几十万级，未来这个数字可能会更大，这决定了蚂蚁单元化架构从容量要求上看必然从单机房走向多机房。另一方面，异地灾备也决定了这些IDC机房必须是异地部署的。
整体上支付宝也采用了三地五中心（IDC机房）来保障系统的可用性[7]，跟2.1中描述的有所不同的是，支付宝将单元分成了三类（也称CRG架构）[8]：
&lt;ul&gt;
  &lt;li&gt;RZone(Region Zone)：直译可能有点反而不好理解。实际上就是所有可以分库分表的业务系统整体部署的最小单元。每个RZone连上数据库就可以撑起一片天空，把业务跑的溜溜的。&lt;/li&gt;
  &lt;li&gt;GZone(Global Zone)：全局单元，意味着全局只有一份。部署了不可开创副本服务和数据，比如汇率、优惠政策、商品价格、系统配置等。实际情况下，GZone异地也会部署，不过仅是用于灾备，同一时刻，只有一地GZone进行全局服务。GZone一般被RZone依赖，提供的大部分是读取服务。&lt;/li&gt;
  &lt;li&gt;CZone(City Zone)：顾名思义，这是以城市为单位部署的单元。同样部署了不可拆分的数据和服务，比如用户账号服务，客户信息服务等。理论上CZone会被RZone以比访问GZone高很多的频率进行访问。CZone是基于特定的GZone场景进行优化的一种单元，它把GZone中有些有着”写读时间差现象”的数据和服务进行了的单独部署，这样RZone只需要访问本地的CZone即可，而不是访问异地的GZone。&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
  “写读时间差现象”是架构师们根据实践统计总结的，他们发现大部分情况下，一个数据被写入后，都会过足够长的时间后才会被访问。生活中这种例子很常见，我们办完银行卡后可能很久才会存第一笔钱；我们创建微博账号后，可能想半天才会发微博；我们下载创建淘宝账号后，可能得浏览好几分钟才会下单买东西。当然了这些例子中的时间差远远超过了系统同步时间。一般来说异地的延时在100ms以内，所以只要满足某地CZone写入数据后100ms以后才用这个数据，这样的数据和服务就适合放到CZone中。
&lt;/blockquote&gt;

相信大家看到这都会问：为啥分这三种单元？其实其背后对应的是不同性质的数据，而服务不过是对数据的操作集。下面我们来根据数据性质的不同来解释支付宝的CRG架构。当下几乎所有互联网公司的分库分表规则都是根据用户ID来制定的，而围绕用户来看整个系统的数据可以分为以下两类：用户专属型数据和用户间共享型数据。

&lt;blockquote&gt;
  注：网上和支付宝内部有另外一些分法，比如流水型和状态性，有时候还会分为三类：流水型、状态型和配置型。
&lt;/blockquote&gt;

（1）用户专属型数据

代表只有用户自己会访问的数据，典型的有用户的订单、用户发的评论、用户的行为记录等。这些数据都是用户行为产生的流水型数据，具备天然的用户隔离性，比如A用户的App上绝对看不到B用户的订单列表。所以此类数据非常适合分库分表后独立部署服务，即按照用户ID散列部署为RZone。

（2）用户共享型数据

代表所有的用户都可能访问的数据。由于数据可能会被所有用户访问，将提供这类数据的服务部署到RZone就变得不合适了，因为RZone可能被分布在全国各地，高频的远程调用并不经济。用户共享型数据又可以进一步分为以下几类：
&lt;ul&gt;
  &lt;li&gt;时间差弱感型数据：这些数据往往对一致性的实时性不敏感，比如上海的某个用户写了一条评论，一般并不会强调广东深圳的另一个用户与上海的其他用户需要同时并立即看到这条评论。其他类似的还有账号、个人博客、商品等。由于对时间差不敏感，这类数据的提供服务往往被部署到CZone中，&lt;/li&gt;
  &lt;li&gt;时间差敏感型数据：代表这些数据对时间差很敏感，不允许出现过期副本，比如不允许超卖的库存，公共账户余额等。这些数据对应的服务一般会部署为GZone服务，每一次数据访问都会路由到全局唯一的数据库中进行处理。GZone中的服务在多地部署的架构下调用是低效的，幸运的是这种类型的数据在所有业务数据中只占很小的一部分。&lt;/li&gt;
  &lt;li&gt;低频访问的配置型数据：系统配置是共享型数据中比较常见的一种类型，有些配置是时间差敏感的有些则是弱感的，但即便是时间差弱感型数据，我们常常也并不会因此将其与其他配置分开部署到RZone或者CZone中（特殊情况下有必要也只能部署到RZone或CZone），因为大部分配置数据都是低频访问的，比如运营后台配置的活动数据等，这些更新可能在运动开始前被RZone服务加载后就不再高频访问了，放在GZone更为方便和节约成本。作者在支付宝所搭建的价格工厂用于制定各项业务的收费规则，它也被部署到了GZone中，因为金融产品的收费规则的使用方往往都不是高并发入口，甚至有些是离线业务。&lt;/li&gt;
&lt;/ul&gt;

以上只是从数据特性上做了分类，具体的案例场景并不具备必然的参考意义，具体使用什么方式部署，需要结合业务场景进行判断。即便在支付宝的实际应用中，各个系统仍然存在不合理的CRG分类，尤其是CG不分的现象很常见。为了避免过度设计，作者建议共享型数据服务一开始可以优先考虑放到GZone中，当逐步发现瓶颈时再对数据做划分，逐步引入CZone。

&lt;h2 id=&quot;3-ldc单元化的异地多活和灾备&quot;&gt;3 LDC单元化的异地多活和灾备&lt;/h2&gt;

&lt;h3 id=&quot;31-流量挑拨技术探秘简介&quot;&gt;3.1 流量挑拨技术探秘简介&lt;/h3&gt;

单元化后，异地多活从未如此简单——只需要在多地进行单元部署而已。比如上海的两个单元负责用户ID范围为[00~19],[40~59]的用户服务，而杭州的两个单元为ID为[20~39]和[60,79]的用户服务，这样上海和杭州就是异地双活的。

支付宝对单元化的基本要求是每个单元都具备服务所有用户的能力，以应对不可预期的天灾人祸，即具体的哪个单元服务哪些用户是可以动态配置的。所以异地双活的这些单元还充当了彼此的备份。

&lt;blockquote&gt;
  发现工作中冷备热备已经被用的很乱了。最早冷备是指数据库在备份数据时需要关闭后进行备份（也叫离线备份），防止数据备份过程中又修改了，不需要关闭即在运行过程中进行数据备份的方式叫做热备(也叫在线备份)[9]。也不知道从哪一天开始，冷备在主备系统里代表了这台备用机器是关闭状态的，只有主服务器挂了之后，备服务器才会被启动；而相同的热备变成了备服务器也是启动的，只是没有流量而已，一旦主服务器挂了之后，流量自动打到备服务器上。本文不打算用第二种理解，因为感觉有点野、、、
&lt;/blockquote&gt;

为了做到每个单元访问哪些用户变成可配置，支付宝要求单元化管理系统具备流量到单元的可配置以及单元到DB的可配置能力，如下图所示：

&lt;img src=&quot;/image/ant-ldc-arch/ant-unit-request-control.png&quot; alt=&quot;蚂蚁单元化流量挑拨架构&quot; /&gt;

其中spanner是基于nginx自研的反向代理网关，也很好理解，有些请求我们希望在反向代理层就被转发至其他IDC的spanner而无需进入后端服务，如图箭头2所示。那么对于应该在本IDC处理的请求，就直接映射到对应的RZ即可，如图箭头1。进入后端服务后，理论上如果请求只是读取用户专属型数据，那么一般不会再进行路由了。然而对于有些场景来说，A用户的一个请求可能关联了对B用户数据的访问，比如A转账给B，A扣完钱后要调用账务系统去增加B的余额。这时候就涉及到再次的路由，同样有两个结果：跳转到其他IDC（如图箭头3）或是跳转到本IDC的其他RZone（如图箭头4）。

RZone到DB数据分区的访问这是事先配置好的，上图中RZ和DB数据分区的关系为：

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;RZ0* --&amp;gt; a
RZ1* --&amp;gt; b
RZ2* --&amp;gt; c
RZ3* --&amp;gt; d
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

下面我们举个例子来说明整个流量挑拨的过程，假设C用户所属的数据分区是c，而C用户在杭州访问了cashier.xxx.com（随便编的）。

（1）首先默认会按照地域来路由流量，具体的实现承载者是全局负载均衡GLSB（Global Server Load Balancing），它会根据请求者的IP，自动将cashier.xxx.com解析为杭州IDC的IP地址（或者跳转到IDC所在的域名）。自己搞过网站的同学应该知道大部分DNS服务商的地址都是靠人去配置的，GLSB属于动态配置域名的系统，网上也有比较火的类似产品，比如花生壳之类（建过私站的同学应该很熟悉）的。

（2）好了，到此为止，用户的请求来到了IDC-1的Spanner集群服务器上，Spanner从内存中读取到了路由配置，知道了这个请求的主体用户C所属的RZ2*不在本IDC，于是直接转到了IDC-2进行处理。

（3）进入IDC-2之后，根据流量配比规则，该请求被分配到了RZ3B进行处理。

（4）RZ2B(或者RZ2A)得到请求后对数据分区c进行访问。

（5）处理完毕后原路返回。

大家应该发现问题所在了，如果再来一个这样的请求，岂不是每次都要跨地域进行调用和返回体传递？确实是存在这样的问题的，对于这种问题，支付宝架构师们决定继续把决策逻辑往用户终端推移。比如，每个IDC机房都会有自己的域名（真实情况可能不是这样命名的）:
IDC-1对应cashieridc-1.xxx.com
IDC-2对应cashieridc-2.xxx.com
那么请求从IDC-1涮过一遍返回时会将前端请求跳转到cashieridc-2.xxx.com去（如果是APP，只需要替换rest调用的接口域名），后面所有用户的行为都会在这个域名上发生，就避免了走一遍IDC-1带来的延时。

&lt;h3 id=&quot;32-灾备机制&quot;&gt;3.2 灾备机制&lt;/h3&gt;

流量挑拨是灾备切换的基础和前提条件，发生灾难后的通用方法就是把陷入灾难的单元的流量重新打到正常的单元上去，这个流量切换的过程俗称切流。支付宝LDC架构下的灾备有三个层次：

&lt;ul&gt;
  &lt;li&gt;同机房单元间灾备。&lt;/li&gt;
  &lt;li&gt;同城机房间灾备。&lt;/li&gt;
  &lt;li&gt;异地机房间灾备。&lt;/li&gt;
&lt;/ul&gt;

(1) 同机房单元间灾备

灾难发生可能性相对最高（但其实也很小）。对LDC来说，最小的灾难就是某个单元由于一些原因（局部插座断开、线路老化、人为操作失误）宕机了。从3.1节里的图中可以看到每组RZ都有A，B两个单元，这就是用来做同机房灾备的，并且AB之间也是双活双备的，正常情况下AB两个单元共同分担所有的请求，一旦A单元挂了，B单元将自动承担A单元的流量份额。这个灾备方案是默认的。

(2) 同城机房间灾备

灾难发生可能性相对更小。这种灾难发生的原因一般是机房电线网线被挖断，或者机房维护人员操作失误导致的。在这种情况下，就需要人工的制定流量挑拨（切流）方案了。下面我们举例说明这个过程，如下图所示为上海的两个IDC机房。

&lt;img src=&quot;/image/ant-ldc-arch/disaster-backup.png&quot; alt=&quot;同城双机房灾备演练&quot; /&gt;

整个切流配置过程分两步，首先需要将陷入灾难的机房中RZone对应的数据分区的访问权配置进行修改；假设我们的方案是由IDC-2机房的RZ2&lt;em&gt;和RZ3&lt;/em&gt;分别接管IDC-1中的RZ0&lt;em&gt;和RZ1&lt;/em&gt;。那么首先要做的是把IDC2中的数据分区a，b对应的访问权从RZ0&lt;em&gt;和RZ1&lt;/em&gt;收回。分配给RZ2&lt;em&gt;和RZ3&lt;/em&gt;。即将（如上图所示为初始映射）：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;RZ0* --&amp;gt; a
RZ1* --&amp;gt; b
RZ2* --&amp;gt; c
RZ3* --&amp;gt; d
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
变为：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;RZ0* --&amp;gt; /
RZ1* --&amp;gt; /
RZ2* --&amp;gt; a
RZ2* --&amp;gt; c
RZ3* --&amp;gt; b
RZ3* --&amp;gt; d
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

然后再修改用户ID和RZ之间的映射配置。假设之前为:
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;[00-24] --&amp;gt; RZ0A(50%),RZOB(50%)
[25-49] --&amp;gt; RZ1A(50%),RZ1B(50%)
[50-74] --&amp;gt; RZ2A(50%),RZ2B(50%)
[75-99] --&amp;gt; RZ3A(50%),RZ3B(50%)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
那么按照灾备方案的要求，这个映射配置将变为：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;[00-24] --&amp;gt; RZ2A(50%),RZ2B(50%)
[25-49] --&amp;gt; RZ3A(50%),RZ3B(50%)
[50-74] --&amp;gt; RZ2A(50%),RZ2B(50%)
[75-99] --&amp;gt; RZ3A(50%),RZ3B(50%)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

这样之后，所有流量将会被打到IDC-2中，期间部分已经向IDC-1发起请求的用户会收到失败并重试的提示。
实际情况中，整个过程并不是灾难发生后再去做的，整个切换的流程会以预案配置的形式事先准备好，推送给每个流量挑拨客户端（集成到了所有的服务和spanner中）。

&lt;blockquote&gt;
  这里可以思考下，为何先切数据库映射，再切流量呢？这是因为如果先切流量，意味着大量注定失败的请求会被打到新的正常单元上去，从而影响系统的稳定性（数据库还没准备好）。
&lt;/blockquote&gt;

(2) 异地机房间灾备

这个基本上跟同城机房间灾备一致（这也是单元化的优点），不再赘述。

&lt;h2 id=&quot;4-ldc单元化架构的cap分析&quot;&gt;4 LDC单元化架构的CAP分析&lt;/h2&gt;

&lt;h3 id=&quot;41-回顾cap&quot;&gt;4.1 回顾CAP&lt;/h3&gt;

&lt;h4 id=&quot;411-cap的定义&quot;&gt;4.1.1 CAP的定义&lt;/h4&gt;
CAP原则是指任意一个分布式系统，同时最多只能满足其中的两项，而无法同时满足三项。所谓的分布式系统，说白了就是一件事一个人做的，现在分给好几个人一起干。我们先简单回顾下CAP各个维度的含义[1]：
&lt;ul&gt;
  &lt;li&gt;Consistency（一致性），这个理解起来很简单，就是每个操作结束后节点上的同一份数据都是一致的。保证一致性往往有两种方法，一种是要求任何更新都是原子的，即要么全部成功，要么全部失败。由于分布式系统之间无法做到像单机一样对系统资源的全把控能力，保证整个分布式系统的原子性也变得十分奢侈。另外一种一致性保障方法是通过分布式仲裁的方法，比如CouchDB等数据库，当数据更新发现冲突时，将通过预先设置的规则进行分布式仲裁，最终得到一个全局一致的数据。&lt;/li&gt;
  &lt;li&gt;Availability（可用性），这个可用性看起来很容易理解，但真正说清楚的不多。 这里的可用性和整个系统的“高可用度”没啥关系，这里是指整个分布式系统还有节点活着的时候，是不是每个节点都能快速处理请求和返回结果。所以一句话解释就是：“是否所有节点都可服务”。&lt;/li&gt;
  &lt;li&gt;Partition tolerance（分区容忍性），这个可能也是很多文章都没说清楚的。P并不是像CA一样是一个独立的性质，它依托于CA来进行讨论。参考文献[1]中解释道：”除非整个网络瘫痪，否则任何时刻系统都能正常工作”，言下之意是小范围的网络瘫痪，节点宕机，都不会影响整个系统的CA。我感觉这个解释听着还是有点懵逼，所以个人更愿意解释为”当节点之间网络不通时（出现网络分区），可用性和一致性仍然能得到保障”。因此按笔者的理解，分区容忍性又分为”可用性分区容忍性”和”一致性分区容忍性”。&lt;/li&gt;
&lt;/ul&gt;

下图为CAP之间的经典关系图：

&lt;img src=&quot;/image/ant-ldc-arch/cap-principle.jpg&quot; alt=&quot;CAP关系图&quot; /&gt;

还有个需要说明的地方，“分布式系统不可能同时满足CAP“的前提条件是这个分布式系统一定是有读有写的，如果只考虑读，那么CAP很容易都满足，比如一个计算器服务，接受表达式请求，返回计算结果，搞成水平扩展的分布式，显然这样的系统没有一致性问题，网络分区也不怕，可用性也是很稳的，所以可以满足CAP。而对于需要分布式读写的系统则符合CAP约束，分布式读写意味着在A点写入的数据，在B点也可以读取，这样的系统无法在任一时刻同时满足CAP。

&lt;h4 id=&quot;412-cap分析方法&quot;&gt;4.1.2 CAP分析方法&lt;/h4&gt;

先说下CA和P的关系，如果不考虑P的话，系统是可以轻松实现CA的。而P并不是一个单独的性质，它代表的是目标分布式系统有没有对网络分区的情况做容错处理。如果做了处理，就一定是带有P的，接下来再考虑分区情况下到底选择了A还是C。所以分析CAP，建议先确定有没有对分区情况做容错处理。
以下是个人总结的分析一个分布式系统CAP满足情况的一般方法：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;if( 不存在分区的可能性 ){// 单体非分布式系统
    return &apos;AC&apos;
}
else{  
    if(可用性分区容忍性-A under P)）
      return &quot;AP&quot;;
    else if(一致性分区容忍性-C under P）
      return &quot;CP&quot;;
}

&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;blockquote&gt;
  也就意味着，分布式系统一定是AP或者CP的
&lt;/blockquote&gt;

&lt;h3 id=&quot;42-水平扩展应用单数据库实例的cap分析&quot;&gt;4.2 水平扩展应用+单数据库实例的CAP分析&lt;/h3&gt;

让我们再来回顾下分布式应用系统的来由，早年每个应用都是单体的，跑在一个服务器上，服务器一挂，服务就不可用了（这就是AC）。另外一方面，单体应用由于业务功能复杂，对机器的要求也逐渐变高，普通的微机无法满足这种性能和容量的要求。所以要拆！还在IBM大卖小型商用机的年代，阿里巴巴就提出要以分布式微机替代小型机。所以我们发现，分布式系统解决的最大的痛点，就是单体单机系统的可用性问题。要想高可用，必须分布式。
一家互联网公司的发展之路上，第一次与分布式相遇应该都是在单体应用的水平扩展上。也就是同一个应用启动了多个实例，连接着相同的数据库（为了简化问题，先不考虑数据库是否单点），如下图所示。

&lt;img src=&quot;/image/ant-ldc-arch/horizontal-scale-arch.jpg&quot; alt=&quot;多服务单数据库&quot; /&gt;

这样的系统天然具有的就是AP（可用性和分区容忍性），一方面解决了单点导致的低可用性问题，另一方面无论这些水平扩展的机器间网络是否出现分区，这些服务器都可以各自提供服务，因为他们之间不需要进行沟通。然而，这样的系统是没有一致性可言的，当每个实例都可以往数据库insert和update（注意这里还没讨论到事务）时，数据就乱套了。

于是我们转向了让DB去做这个事，这时候”数据库事务”就被用上了。用大部分公司会选择的Mysql/MariaDB来举例，用了事务之后会发现数据库又变成了单点和瓶颈，这样就变成AC系统了。这里有一个很容易错误的概念：AC系统其实并不是高可用的，可用性的一个隐含含义是指整个系统至少还有活着的节点时每个节点都可以提供服务，而不是指整个系统的高可用度。AC的系统高可用度肯定没有AP和CP来的好。

&lt;h3 id=&quot;43-水平扩展应用主从数据库集群的cap分析&quot;&gt;4.3 水平扩展应用+主从数据库集群的CAP分析&lt;/h3&gt;

上一节我们讨论了多应用实例+单数据库实例的模式，这种模式是分布式系统也好，不是分布式系统也罢，整体是偏CP的。现实中，技术人员们也会很快发现这种架构的不合理性——可用性太低了。于是如下图所示的模式成为了当下大部分中小公司所使用的架构：

&lt;img src=&quot;/image/ant-ldc-arch/horizontal-scale-db-arch.jpg&quot; alt=&quot;多服务多数据库&quot; /&gt;

从上图我可以看到三个数据库实例中只有一个是主库，其他是从库。一定程度上，这种架构极大的缓解了”读可用性”问题，而这样的架构一般会做读写分离来达到更高的”读可用性”，幸运的是大部分互联网场景中读都占了80%以上，所以这样的架构能得到较长时间的广泛应用。对于”写可用性”方面主备模式可以采用keepalived[4]等HA（高可用）框架来保证主库的存活性，但实质上这种方式并没有带来性能上的可用性提升，只是保证了宕机情况下的可用性，至少系统不会因为某个实例挂了就都不可用了。该分布式系统可用性勉强达标了，具体的CAP分析如下：
&lt;ul&gt;
  &lt;li&gt;这是一个多节点系统，因此肯定不是AC。&lt;/li&gt;
  &lt;li&gt;一致性：如果mysql集群方案采用全同步复制，那么这样的集群就是CP的。&lt;/li&gt;
  &lt;li&gt;可用性：如果mysql集群方案采用异步复制（默认），那么这样的集群就是AP的。（都可以响应请求，但是数据不一致）&lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;44-ldc单元化架构的cap分析&quot;&gt;4.4 LDC单元化架构的CAP分析&lt;/h3&gt;

&lt;h4 id=&quot;441-战胜分区容忍性&quot;&gt;4.4.1 战胜分区容忍性&lt;/h4&gt;

分区的产生一般有两种情况：
&lt;ul&gt;
  &lt;li&gt;某台机器宕机了，过一会儿又重启了，看起来就像失联了一段时间，像是网络不可达一样。&lt;/li&gt;
  &lt;li&gt;异地部署情况下，异地多活意味着每一地都可能会产生数据写入，而异地之间偶尔的网络延时尖刺（网络延时曲线图陡增）、网络故障都会导致小范围的网络分区产生。前文也提到过，如果一个分布式系统是部署在一个局域网内的（一个物理机房内），那么个人认为分区的概率极低，即便有复杂的拓扑，也很少会有在同一个机房里出现网络分区的情况。而异地这个概率会大大增高，所以蚂蚁的三地五中心必须需要思考这样的问题，分区容忍不能丢！同样的情况还会发生在不同ISP的机房之间（想象一下你和朋友组队玩DOTA，他在电信，你在联通）。为了应对某一时刻某个机房突发的网络延时尖刺活着间歇性失联，一个好的分布式系统一定能处理好这种情况下的一致性问题。&lt;/li&gt;
&lt;/ul&gt;

那么蚂蚁是怎么解决这个问题的呢？我们在4.2的备注部分讨论过，其实LDC机房的各个单元都由两部分组成：负责业务逻辑计算的应用服务器和负责数据持久化的数据库。大部分应用服务器就像一个个计算器，自身是不对写一致性负责的(无状态服务)，这个任务被下沉到了数据库。所以蚂蚁解决分布式一致性问题的关键就在于数据库！

想必有些读者大概猜到下面的讨论重点了——OceanBase（下文简称OB），中国第一款自主研发的分布式数据库，一时间也确实获得了很多光环。在讨论OB前，我们先来想想Why not MySQL?

首先，就像CAP三角图中指出的，单机MySQL是一款满足AC但不满足P的分布式系统，不满足，PASS；其次如果是主从架构+异步模式，AP，这样会牺牲一致性，这在金融行业是致命的；最后，如果是全同步模式的话，虽然是CP，但是这个A低的离谱，只要有一个节点分区了，每个节点都无法再响应读/写请求。

所以，我们的目标就是在分区容忍的情况下，如果满足了A/C，剩下的C/A一定要尽可能的满足，不能完全掉链子。

那么如何才能让分布式系统具备分区容忍性呢？按照老惯例，我们从”可用性分区容忍”和”一致性分区容忍”两个方面来讨论。

(1) 可用性分区容忍性保障机制（AP）

如果我们选择了AP，那就意味着我们的挑战就是搞定C了，从CAP理论上就抹掉了同时满足C的可能性。这时候“最终一致性”（BASE）出现了，CouchDB等数据库就是类似的实现。这种架构下，系统允许2个并发的请求各自写入不同的节点，当数据更新发现冲突时，将通过预先设置的规则进行分布式仲裁，最终得到一个全局一致的数据。

(2) 一致性分区容忍性保障机制（CP）

老实说，都产生分区了，哪还可能获得实时一致性。但要保证最终一致性也不简单，一旦产生分区，如何在2个分区无法通信的情况下保证只有有一份正确的提议呢？究其根本是要保障所有分区种有且只能有一个大脑，下面我们来看下共识算法PAXOS的核心——Quorum思想是如何解决脑裂问题的。

&lt;blockquote&gt;
  这里可以发散下，所谓的”脑”其实就是具备写能力的系统，”非脑”就是只具备读能力的系统，对应了MySQL集群中的从库。
&lt;/blockquote&gt;

下面是两段摘自维基百科的PAXOS定义[5]：

&lt;em&gt;Paxos is a family of protocols for solving consensus in a network of unreliable processors (that is, processors that may fail).&lt;/em&gt;

&lt;em&gt;Quorums express the safety (or consistency) properties of Paxos by ensuring at least some surviving processor retains knowledge of the results.&lt;/em&gt;

这段话的意思是：PAXOS是在一群不可靠的节点组成的集群中的一类共识机制，而Quorum机制则用来保证。众所周知Paxos算法可以解决分布式系统中的脑裂问题，但其中真正起作用的本质思想是Quorum机制，翻译过来叫做“法定数量机制”，在分布式领域，它往往要求任何一个提议在一个有N个节点的分布式系统中至少被(N/2)+1个系统节点所认可，它才被认为是可信的，这背后的理论基础是少数服从多数——一个群体不可能存在2种对立的多数群体观点。只要多数节点认可并持久化数据，即便整个系统宕机了，在重启后该系统仍然可以通过一次互相通信知道哪个值是合法的——多数节点保留的那个值。这样的设定也巧妙的解决了分区情况下的共识问题，因为一旦产生分区，势必最多只有一个分区内的节点数量会大于等于(N/2)+1。也有一些HA（高可用）方案通过依托于另一个仲裁系统来避免脑裂，比如大家同时Ping一个公共的IP，先成功者继续为脑，然而显然这就又制造了另外一个单点——仲裁系统的高可用谁来保障？

&lt;blockquote&gt;
  如果你了解过比特币或者区块链，你就知道区块链的基础理论也是Quorum法定数量机制。区块链借助Quorum机制来抵御恶意篡改，分布式应用系统则是借助Quorum来解决分区脑裂问题。不过区块链假设的是网络中存在拜占庭错误，因而法定数量并不是(N/2)+1，具体可搜索相关技术文章。
&lt;/blockquote&gt;

很多同学肯定听说过这样的描述——PAXOS是唯一能解决分布式一致性问题的解法。实际上PAXOS并没有逃离CAP魔咒，它实现强一致的后果是处于弱势分区的节点将无法再提供写入服务（或者一致性读服务）。

&lt;h4 id=&quot;442-oceanbase的cap分析&quot;&gt;4.4.2 OceanBase的CAP分析&lt;/h4&gt;

上文提到过，单元化架构中的成千山万的应用就像是计算器，本身无CAP限制，其CAP限制和挑战下沉到了数据库层——蚂蚁自研的分布式数据库OceanBase（本节简称OB）[6]。在OB体系中，每个数据库实例都具备读写能力，具体是读是写可以动态配置（参考2.2部分）。实际情况下大部分时候，对于某一类数据（固定用户号段的数据）任意时刻只有一个单元会负责写入某个节点，其他节点要么是实时库间同步，要么是异步数据同步。OB也采用了PAXOS共识协议，实时库间同步的节点(包含自己)个数至少需要(N/2)+1个，这样就可以解决分区容忍性问题，因此OB是一个CP系统。

下面我们举个马老师改英文名的例子来说明OB设计的精妙之处。假设数据库按照用户ID分库分表，马老师的用户ID对应的数据段在[0-9]，由A单元负责数据写入，假如马老师（用户ID假设为000）正在用支付宝APP修改自己的英文名，马老师一开始打错了，打成了Jason Ma，马老师看到修改的按钮还可以点击，立马将名字改成了Jack Ma并重新提交。当第一个请求来到A单元时，突然A单元网络断开了（分区产生了），系统执行了预先配置的灾备策略自动将A单元对数据段[0,9]的写入权限转交给B单元（更改映射），这时候第二个请求便来到了B单元。由于在网络断开前请求已经进入了A，写权限转交给单元B生效后，A和B同时对[0,9]数据段进行写入马老师的英文名。假如这时候不做任何的分区容忍性保障即都允许写入的话就会出现不一致，A单元说我看到马老师设置了Jason Ma，B单元说我看到马老师设置了Jack Ma。而在OB中这种情况永远不会发生——当A单元数据库实例向整个系统提议说我建议把马老师的英文名设置为Jason Ma时，发现没人回应它，由于出现了分区，其他节点对它来说都是不可达的，所以这个提议被自动丢弃，A心里也明白是自己分区了，会有主分区替自己完成写入任务的。同样的，当B单元数据库实例提出将马老师的英文名改成Jack Ma后，大部分节点都响应了，所以B成功将Jack Ma写入了马老师的账号记录中。假如在写权限转交给单元B后A突然恢复了，也没关系，两笔写请求同时要求获得(N/2)+1个节点的事务锁，通过no-wait设计，在B获得了锁之后，其他争抢该锁的事务都会因为失败而回滚。

&lt;blockquote&gt;
  No-wait设计的思想在于当发现所访问的资源出现竞争时，不等待资源释放，而是直接返回失败。
&lt;/blockquote&gt;

所以OB仍然没有逃脱CAP魔咒，它是一个强一致的数据库，因此它的“任意节点可用性”并不能保障，但这丝毫不影响整个数据库系统的“高可用”，注意别搞混了。

&lt;h2 id=&quot;5-结语&quot;&gt;5 结语&lt;/h2&gt;

个人感觉本文涉及到的知识面确实不少，每个点单独展开都可以讨论半天。回到我们紧扣的主旨来看，双十一海量支付背后技术上大快人心的设计到底是啥？我想无非是以下几点：

&lt;ul&gt;
  &lt;li&gt;基于用户分库分表的RZone设计。每个用户群独占一个单元给整个系统的容量带来了爆发式增长。&lt;/li&gt;
  &lt;li&gt;RZone在网络分区或灾备切换时OB的防脑裂设计（PAXOS）。我们知道RZone是单脑的（读写都在一个单元对应的库），而网络分区或者灾备时热切换过程中可能会产生多个脑，OB解决了脑裂情况下的共识问题（PAXOS算法）。&lt;/li&gt;
  &lt;li&gt;基于CZone的本地（地理上的本地）读设计。这一点保证了很大一部分有着“写读时间差”现象的公共数据能被高速本地访问。&lt;/li&gt;
  &lt;li&gt;剩下的那一丢丢不能本地访问只能实时远程访问GZone的公共配置数据，也兴不起什么风，作不了什么浪。大部分瓶颈场景都可以通过优化系统设计来解决，比如对于实时库存数据，可以通过“页面展示查询走应用层缓存”+“实际下单时再校验”的方式减少其GZone调用量。&lt;/li&gt;
&lt;/ul&gt;

而这就是蚂蚁LDC的CRG架构，理论上TPS数字可以做到更高，但双十一海量支付的成功不单单是这么一套设计所决定的，还有预热削峰等运营+技术的手段，在此感谢阿里巴巴全体技术给大家带来的一年一度的购物盛宴。

感谢大家的阅读，文中可能存在不足或遗漏之处，欢迎批评指正。

&lt;blockquote&gt;
  本文为个人留档使用，未经允许，不得转载。
&lt;/blockquote&gt;

&lt;h2 id=&quot;6-参考文献&quot;&gt;6 参考文献&lt;/h2&gt;

[1] Practice of Cloud System Administration, The: DevOps and SRE Practices for Web Services, Volume 2. Thomas A. Limoncelli, Strata R. Chalup, Christina J. Hogan.

[2] MySQL 5.7半同步复制技术. https://www.cnblogs.com/zero-gg/p/9057092.html

[3] BASE理论分析; https://www.jianshu.com/p/f6157118e54b

[4] Keepalived; https://baike.baidu.com/item/Keepalived/10346758?fr=aladdin

[5] PAXOS; https://en.wikipedia.org/wiki/Paxos_(computer_science)

[6] OceanBase支撑2135亿成交额背后的技术原理; https://www.cnblogs.com/antfin/articles/10299396.html

[7] 三地五中心,蚂蚁金服金融行业安全最高标准技术开放,光缆挖断业务照样用; https://www.sohu.com/a/255067828_114921

[8] 阿里双11技术详解：容量规划+LDC+弹性架构+大促中控等; https://my.oschina.net/u/4383176/blog/4713897

[9] Backup; https://en.wikipedia.org/wiki/Backup

&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#1-背景&quot; id=&quot;markdown-toc-1-背景&quot;&gt;1 背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#2-ldc和单元化&quot; id=&quot;markdown-toc-2-ldc和单元化&quot;&gt;2 LDC和单元化&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#21-系统架构演化史&quot; id=&quot;markdown-toc-21-系统架构演化史&quot;&gt;2.1 系统架构演化史&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#22-支付宝单元化架构实践&quot; id=&quot;markdown-toc-22-支付宝单元化架构实践&quot;&gt;2.2 支付宝单元化架构实践&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#3-ldc单元化的异地多活和灾备&quot; id=&quot;markdown-toc-3-ldc单元化的异地多活和灾备&quot;&gt;3 LDC单元化的异地多活和灾备&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#31-流量挑拨技术探秘简介&quot; id=&quot;markdown-toc-31-流量挑拨技术探秘简介&quot;&gt;3.1 流量挑拨技术探秘简介&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#32-灾备机制&quot; id=&quot;markdown-toc-32-灾备机制&quot;&gt;3.2 灾备机制&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#4-ldc单元化架构的cap分析&quot; id=&quot;markdown-toc-4-ldc单元化架构的cap分析&quot;&gt;4 LDC单元化架构的CAP分析&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#41-回顾cap&quot; id=&quot;markdown-toc-41-回顾cap&quot;&gt;4.1 回顾CAP&lt;/a&gt;        &lt;ul&gt;
          &lt;li&gt;&lt;a href=&quot;#411-cap的定义&quot; id=&quot;markdown-toc-411-cap的定义&quot;&gt;4.1.1 CAP的定义&lt;/a&gt;&lt;/li&gt;
          &lt;li&gt;&lt;a href=&quot;#412-cap分析方法&quot; id=&quot;markdown-toc-412-cap分析方法&quot;&gt;4.1.2 CAP分析方法&lt;/a&gt;&lt;/li&gt;
        &lt;/ul&gt;
      &lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#42-水平扩展应用单数据库实例的cap分析&quot; id=&quot;markdown-toc-42-水平扩展应用单数据库实例的cap分析&quot;&gt;4.2 水平扩展应用+单数据库实例的CAP分析&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#43-水平扩展应用主从数据库集群的cap分析&quot; id=&quot;markdown-toc-43-水平扩展应用主从数据库集群的cap分析&quot;&gt;4.3 水平扩展应用+主从数据库集群的CAP分析&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#44-ldc单元化架构的cap分析&quot; id=&quot;markdown-toc-44-ldc单元化架构的cap分析&quot;&gt;4.4 LDC单元化架构的CAP分析&lt;/a&gt;        &lt;ul&gt;
          &lt;li&gt;&lt;a href=&quot;#441-战胜分区容忍性&quot; id=&quot;markdown-toc-441-战胜分区容忍性&quot;&gt;4.4.1 战胜分区容忍性&lt;/a&gt;&lt;/li&gt;
          &lt;li&gt;&lt;a href=&quot;#442-oceanbase的cap分析&quot; id=&quot;markdown-toc-442-oceanbase的cap分析&quot;&gt;4.4.2 OceanBase的CAP分析&lt;/a&gt;&lt;/li&gt;
        &lt;/ul&gt;
      &lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#5-结语&quot; id=&quot;markdown-toc-5-结语&quot;&gt;5 结语&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#6-参考文献&quot; id=&quot;markdown-toc-6-参考文献&quot;&gt;6 参考文献&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
        <pubDate>Sun, 10 Nov 2019 06:49:18 +0000</pubDate>
        <link>https://tbwork.github.io/2019/11/10/ant-ldc-arch/</link>
        <guid isPermaLink="true">https://tbwork.github.io/2019/11/10/ant-ldc-arch/</guid>
        
        <category>单元化</category>
        
        <category>CAP</category>
        
        <category>异地多活</category>
        
        
        <category>架构师</category>
        
      </item>
    
      <item>
        <title>Maven父子模块统一版本配置方案</title>
        <description>&lt;strong&gt;注意，以下教程请确认MAVEN版本 &amp;gt;= 3.5.0，尤其使用IDEA自带maven的同学务必确认。&lt;/strong&gt;
&lt;strong&gt;IDEA 2019.02版本与部分新版本maven(&amp;gt;=3.6.2)不兼容，请更新IDEA到最新版。&lt;/strong&gt;

&lt;h3 id=&quot;1-修改父pom的版本如下&quot;&gt;1 修改父Pom的版本。如下：&lt;/h3&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&amp;lt;groupId&amp;gt;com.xxxx.yyyy&amp;lt;/groupId&amp;gt;
&amp;lt;artifactId&amp;gt;parent&amp;lt;/artifactId&amp;gt;
&amp;lt;version&amp;gt;${revision}&amp;lt;/version&amp;gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h3 id=&quot;2-修改主pom添加一个插件如下&quot;&gt;2 修改主Pom，添加一个插件。如下：&lt;/h3&gt;
&lt;div class=&quot;language-xml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;build&amp;gt;&lt;/span&gt;
   &lt;span class=&quot;nt&quot;&gt;&amp;lt;plugins&amp;gt;&lt;/span&gt;
      &lt;span class=&quot;nt&quot;&gt;&amp;lt;plugin&amp;gt;&lt;/span&gt;
         &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;org.codehaus.mojo&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
         &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;flatten-maven-plugin&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
         &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;1.1.0&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
         &lt;span class=&quot;nt&quot;&gt;&amp;lt;configuration&amp;gt;&lt;/span&gt;
            &lt;span class=&quot;nt&quot;&gt;&amp;lt;updatePomFile&amp;gt;&lt;/span&gt;true&lt;span class=&quot;nt&quot;&gt;&amp;lt;/updatePomFile&amp;gt;&lt;/span&gt;
            &lt;span class=&quot;nt&quot;&gt;&amp;lt;flattenMode&amp;gt;&lt;/span&gt;resolveCiFriendliesOnly&lt;span class=&quot;nt&quot;&gt;&amp;lt;/flattenMode&amp;gt;&lt;/span&gt;
         &lt;span class=&quot;nt&quot;&gt;&amp;lt;/configuration&amp;gt;&lt;/span&gt;
         &lt;span class=&quot;nt&quot;&gt;&amp;lt;executions&amp;gt;&lt;/span&gt;
            &lt;span class=&quot;nt&quot;&gt;&amp;lt;execution&amp;gt;&lt;/span&gt;
               &lt;span class=&quot;nt&quot;&gt;&amp;lt;id&amp;gt;&lt;/span&gt;flatten&lt;span class=&quot;nt&quot;&gt;&amp;lt;/id&amp;gt;&lt;/span&gt;
               &lt;span class=&quot;nt&quot;&gt;&amp;lt;phase&amp;gt;&lt;/span&gt;process-resources&lt;span class=&quot;nt&quot;&gt;&amp;lt;/phase&amp;gt;&lt;/span&gt;
               &lt;span class=&quot;nt&quot;&gt;&amp;lt;goals&amp;gt;&lt;/span&gt;
                  &lt;span class=&quot;nt&quot;&gt;&amp;lt;goal&amp;gt;&lt;/span&gt;flatten&lt;span class=&quot;nt&quot;&gt;&amp;lt;/goal&amp;gt;&lt;/span&gt;
               &lt;span class=&quot;nt&quot;&gt;&amp;lt;/goals&amp;gt;&lt;/span&gt;
            &lt;span class=&quot;nt&quot;&gt;&amp;lt;/execution&amp;gt;&lt;/span&gt;
            &lt;span class=&quot;nt&quot;&gt;&amp;lt;execution&amp;gt;&lt;/span&gt;
               &lt;span class=&quot;nt&quot;&gt;&amp;lt;id&amp;gt;&lt;/span&gt;flatten.clean&lt;span class=&quot;nt&quot;&gt;&amp;lt;/id&amp;gt;&lt;/span&gt;
               &lt;span class=&quot;nt&quot;&gt;&amp;lt;phase&amp;gt;&lt;/span&gt;clean&lt;span class=&quot;nt&quot;&gt;&amp;lt;/phase&amp;gt;&lt;/span&gt;
               &lt;span class=&quot;nt&quot;&gt;&amp;lt;goals&amp;gt;&lt;/span&gt;
                  &lt;span class=&quot;nt&quot;&gt;&amp;lt;goal&amp;gt;&lt;/span&gt;clean&lt;span class=&quot;nt&quot;&gt;&amp;lt;/goal&amp;gt;&lt;/span&gt;
               &lt;span class=&quot;nt&quot;&gt;&amp;lt;/goals&amp;gt;&lt;/span&gt;
            &lt;span class=&quot;nt&quot;&gt;&amp;lt;/execution&amp;gt;&lt;/span&gt;
         &lt;span class=&quot;nt&quot;&gt;&amp;lt;/executions&amp;gt;&lt;/span&gt;
      &lt;span class=&quot;nt&quot;&gt;&amp;lt;/plugin&amp;gt;&lt;/span&gt;
   &lt;span class=&quot;nt&quot;&gt;&amp;lt;/plugins&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/build&amp;gt;&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h3 id=&quot;3-修改父pom中的properties新增属性如下&quot;&gt;3 修改父Pom中的Properties，新增属性。如下：&lt;/h3&gt;

&lt;div class=&quot;language-xml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;revision&amp;gt;&lt;/span&gt;a.b.c.d-SNAPSHOT&lt;span class=&quot;nt&quot;&gt;&amp;lt;/revision&amp;gt;&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;blockquote&gt;
  其中a,b,c,d一般为数字
&lt;/blockquote&gt;

&lt;h3 id=&quot;4-修改子模块的pom中父版本如下&quot;&gt;4 修改子模块的Pom中父版本。如下：&lt;/h3&gt;

&lt;div class=&quot;language-xml highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;parent&amp;gt;&lt;/span&gt;
   &lt;span class=&quot;nt&quot;&gt;&amp;lt;groupId&amp;gt;&lt;/span&gt;com.juqitech.service&lt;span class=&quot;nt&quot;&gt;&amp;lt;/groupId&amp;gt;&lt;/span&gt;
   &lt;span class=&quot;nt&quot;&gt;&amp;lt;artifactId&amp;gt;&lt;/span&gt;xxxx&lt;span class=&quot;nt&quot;&gt;&amp;lt;/artifactId&amp;gt;&lt;/span&gt;
   &lt;span class=&quot;nt&quot;&gt;&amp;lt;version&amp;gt;&lt;/span&gt;${revision}&lt;span class=&quot;nt&quot;&gt;&amp;lt;/version&amp;gt;&lt;/span&gt;
&lt;span class=&quot;nt&quot;&gt;&amp;lt;/parent&amp;gt;&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

</description>
        <pubDate>Tue, 13 Aug 2019 04:49:08 +0000</pubDate>
        <link>https://tbwork.github.io/2019/08/13/unified-maven-version-for-all-module/</link>
        <guid isPermaLink="true">https://tbwork.github.io/2019/08/13/unified-maven-version-for-all-module/</guid>
        
        <category>Maven</category>
        
        
        <category>研发效率</category>
        
      </item>
    
      <item>
        <title>[译]PAXOS算法白话文版</title>
        <description>&lt;blockquote&gt;
  译者注：网上太多文章解释Paxos算法了，但大多并不完整。本文是早期笔者学习Paxos过程中看到的一篇教程，写的很清晰，遂翻译好给大家阅读。原文：http://lamport.azurewebsites.net/pubs/paxos-simple.pdf
&lt;/blockquote&gt;

&lt;h2 id=&quot;1-介绍&quot;&gt;1 介绍&lt;/h2&gt;
Paxos算法是被设计用于构造一个容错性分布式系统的，但很多人觉得它很难懂，也许是因为它的原版是希腊文[5]。实际上，它是所有分布式算法中最简单和浅显的一类算法了。它的核心是共识算法——一种教会决议算法[5]。下一节会根据大家习惯的问题解决思路来向大家彻底揭开Paxos的面纱。最后一节会将向大家展示整个完整的算法——它甚至可以直接被拿来使用，用以实现分布式系统中的状态机方案——这个著名的叫法在文献[4]中被提出，这篇文献应该是分布式系统理论中被引用最多的文章了。

&lt;h2 id=&quot;2-共识算法&quot;&gt;2 共识算法&lt;/h2&gt;

&lt;h3 id=&quot;21-共识问题&quot;&gt;2.1 共识问题&lt;/h3&gt;

假设有一群可以各自提交自己提案（其实就是一个值）的程序组成了一个分布式系统，那么所谓的“共识算法”就是要保证只有一个程序的提案被整个系统所接受。如果没有任何提案被提出，那么没有任何值将会被选择。如果一个提案被选择了，那么整个系统的程序节点都应该可以学习这个被接受的提案。共识所需要的安全要素有以下这些：
&lt;ul&gt;
  &lt;li&gt;只有一个提案可能被选中。&lt;/li&gt;
  &lt;li&gt;只有一个提案被实际选中。（译者注：这是一句有意义的废话）&lt;/li&gt;
  &lt;li&gt;一个节点永远不会学习一个被选中的旧提案，意味着只会学习一个被选中的最新提案。
我们并不想精确的描述所有要素。说白了，共识的目标就是保证某个提案最终被系统选择，并且所有节点都能最终学习到这个提案。
我们将PAXOS算法中的3个角色表达为3种不同作用的执行人：提案者（proposer）、接收者（acceptor）和学习者（learner）。在算法实现中，一个独立的程序实际上可以同时拥有多个执行人角色，但本文中把他们分开以更好的解释算法，记住这和算法实现里单节点多角色并不冲突。
假设这些执行人互相之间可以通过发送消息来通信。我们用传统异步、非拜占庭模型来做演示这个算法，在这个模型里：&lt;/li&gt;
  &lt;li&gt;每个执行人的处理速度都不一样，有些可能会宕机或者重启。由于每个执行人都可能在提案被选出来之后宕机（但最终会重启），所以任何解决方案都要求节点宕机时可以保留已知的数据。&lt;/li&gt;
  &lt;li&gt;消息在执行人之间传递的速度也是任意的，有可能会重发，也有可能丢失，但绝对不会损坏。&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
  译者注：CRC算法可以保证数据正确性，识别消息损坏的算法已经非常成熟。
&lt;/blockquote&gt;

&lt;h3 id=&quot;22-选择一个提案&quot;&gt;2.2 选择一个提案&lt;/h3&gt;

选择提案最简单的方式是只有一个接收者。任何一个提案者把提案发送给这个接收者，它将选择第一个收到的提案作为最终值。可惜这种简单的方案并不实用，因为一旦这仅有的接收者宕机或出现异常，系统就无法继续工作了。

&lt;blockquote&gt;
  注：这就是单点问题
&lt;/blockquote&gt;

所以我们得换一个思路——用多个接收者来替换单个接收者——一个提案者把自己的提案发送给一系列接收者。每一个接收者都可以选择接受这个提案，而最终只有当足够多的接收者都接受这个提案时，它才算真正被整个系统接受。那么问题来了，”足够多“是多少？为了保证只有一个提案值被接受，我们将这个数字设定为(N/2)+1，其中N是所有接收者的数量。由于每个接收者能且只能接受一个提案值，所以某个提案一旦被”半数+1“的接收者所接受，那就不会出现另一个被多数节点接受的提案[3]。

&lt;blockquote&gt;
  注：一个集体中只可能存在一种不重复的多数——这是一个常识。
&lt;/blockquote&gt;

考虑到接收者可能会宕机、信息可能会丢失，哪怕只有一个提案者发起了一个提案，我们依然希望有一个提案能被接受。这就要求：

条件1: 每个接收者必须接受它收到的第一个提案

这个条件会带来一个新的问题。多个提案者有可能会在同一个时刻发出提案，从而可能出现没有一个提案会被半数以上的接收者所接受。即便只有2个提案者，也可能出现一人一半——多出来的那个节点刚好宕机了。

&lt;blockquote&gt;
  这里有个基本假设——初始接收者集合数量为奇数
&lt;/blockquote&gt;

条件1和前文谈到的“至少有一个提案被半数以上的接受者接受”这两个条件想要被满足，接收者就必须被设计成可以接受多个提案，而不是只能接受一个。我们通过为每个提案添加一个递增的数字编号来跟踪不同的提案，这样一个提案就由两部分组成了：数字编号和提案值，记作(n,v)。为了避免冲突，不同的提案的编号也必须不相同。如何保证这些编号不相同取决于实现方法，目前我们不探讨如何实现，假设它已经实现了。

&lt;blockquote&gt;
  统一递增ID生成方法有很多。
&lt;/blockquote&gt;

一旦某个提案被大多数节点接受了，那么它也就是整个系统所选择的提案。我们允许多个提案被同时接受，只要他们的提案值是一样的。通过引入提案编号，我们足以保证：

条件2：如果一个提案(n,v)被选中了，那么其他被选中的带有更高编号的提案的值也是v。

由于提案编号是递增的，条件2保证了有且只会一个提案值被系统接受。要想被系统接受，任何一个提案必须至少被一个接收者接受，所以只要以下条件被满足，条件2就肯定满足：

条件2-1：如果一个提案(n,v)被接受了，那么任意一个接受者接受的带有更高编号的提案的值就是v。

我们仍然要求满足条件1来确保某个提案会被选中。因为执行人之间的通信是异步的，即便有些接受者由于宕机或者网络问题收不到任何提案，我们也得保证至少有一个提案被整个系统接受。假设这个宕机的接受者节点为c，它重启后立即有一个新的提案者发布了一个带有更高编号和不同提案值的提案，那么条件1就要求接收者c接受这个新提案——因为这是它活过来之后收到的第一个提案，而这违反了条件2-1。要想同时满足条件1和条件2-1，我们必须满足以下条件：

条件2-2：如果一个提案(n,v)被接受了，那么任何提案者发出的带有更高编号的提案的值必须是v。

由于一个提案先得被提交才可能会被接受，条件2-2也就成为了条件2-1的充分条件，当然也是条件2的充分条件。

为了满足条件2-2，我们可以想想如何找到它的充分条件。假设提案(m,v)被选中，并且任何的其他提案（编号&amp;gt;m)的值都是v。为了更好的证明，我们将问题描述为：如果编号为m+1,m+2,…n-1的提案对应的值是v的化那么提案n的值也是v。(m,v)被系统选中意味着存在一个接收者集合C，它的集合数量占整个接收者集合的半数以上。

假设1：集合C中的每个接受者接受到的提案编号范围为[m, n-1]，并且这些提案的值均为v。

由于任何一种多数接受者集合都至少含有一个集合C中的元素，只要下面的条件成立，提案n的值也一定是v。

条件2-3：对于提案(n,v)来说，只要它被发布了，则会存在一个多数接受者组成的集合S，要么S中没有任何节点接受了编号小于n的提案，要么S中接受者收到的编号&amp;lt;n的提案中最大编号提案的值一定是v。

我们只要保证条件2-3是永远成立的，条件2-2也就成立了。

为了让2-3成立，任何一个想要发布编号为n的提案的提案者必须已经知道了所有编号小于n中最大编号的提案——也就是知道了编号为n-1的提案（如果有的话）。如果有小于n的提案，那么这些编号小于n的提案中编号最大的提案已经或者即将会被多数接受者所接受。学习哪些提案已经被接受了是很简单的，预测哪些提案会被接受则是非常困难的。与其预测未来，提案者不如去向接受者要一个承诺——他们不会再接受编号小于n的其他提案。

&lt;blockquote&gt;
  这段的意思其实很简单：当提案者A准备把提案(n,v)发出去后接受者准备返回请求时，可能也有其他的提案(ni&amp;lt;n,vi)正在发送的路途上，这些在途的编号小于n的提案可能存在比提案者A上已知的&amp;lt;n的提案编号更大的提案，但只要接受者返回时保证自己后面不再接受比n更小的提案了，也就无所谓有&amp;lt;n的更大编号的提案了。为了更好的理解，举个例子来说明：
有2个提案者A、B、C，以及一个接受者D。
A 发送提案编号(5,nil) 给D
B 发送提案编号(4,nil) 给D
C 发送提案编号(3,nil) 给D
假设CD、AD的网速很快，BD之间的网速比较慢，具体的过程如下：
  &lt;ol&gt;
    &lt;li&gt;提案(3,nil)先达到D，D回复C：我收到了提案(3,nil)，并且我不再接受比3小的提案了。&lt;/li&gt;
    &lt;li&gt;提案(5,nil)到达了D，D发现5&amp;gt;3可以接受，D回复A：我收到了提案(5,nil)，并且我不再接受比5小的提案了，你放心吧。&lt;/li&gt;
    &lt;li&gt;提案(4,nil)到达了D，D发现4&amp;lt;5，直接丢弃，回复B：你的提案被我扔了，我这最新的提案编号是5。&lt;/li&gt;
  &lt;/ol&gt;

  这样的过程发生在“准备阶段”，这也是为什么paxos算法为什么会有准备阶段的原因。
&lt;/blockquote&gt;

到此为止我们可以得出以下提案者的提案发布算法：

&lt;ol&gt;
  &lt;li&gt;
    一个提案者选择一个新的提案编号n，将其发送给接受者集合中的每个接受者，并要求这些接受者响应以下内容：

    (a) 承诺它不再接受编号小于n的提案。

    (b) 如果有编号小于n的提案被接受，那么也要在返回中附上。
  &lt;/li&gt;
&lt;/ol&gt;

我们把这样的一个发送编号n的请求叫做”准备型请求“。
&lt;ol&gt;
  &lt;li&gt;
    如果提案者收到了来自多数接受者节点的响应，它就可以发布自己的提案详情了（也就是提案编号+提案值），最终发出的提案值有两种可能：

    (a) 如果所有响应里没有发现已经被接受的编号小于n的提案，那么当前提案者发出自己的提案值。

    (b) 否则，在所有响应中找到编号最大的（但小于n）的提案，把它的值作为当前提案者最终发出的提案值。
  &lt;/li&gt;
&lt;/ol&gt;

一个提案者将真正的提案内容（编号+值）发送给一群接受者(这群接受者不一定要和准备阶段的接受者集合一样)，我们把这个请求称之为”采纳型请求“。

&lt;blockquote&gt;
  “采纳型请求”代表这个请求的作用是让接受者采纳请求中的提案。
&lt;/blockquote&gt;

以上阐述了一个提案者所使用的提案算法，那么接受者呢？它将接受2种类型的请求：“准备型请求”和“采纳型请求”。接受者可以在不破坏安全性的前提下忽略任何请求。言下之意是接受者只有在被允许的情况下才能相应某个请求：对于“准备型请求”来说，接受者被始终允许响应这些请求；而对于“采纳型请求”来说，当且仅当它没有承诺过不接受的情况下才可以响应这些请求。换句话说：

条件1-1 一个接受者可以接受编号为n的提案的前提是——它没有响应过任何一个编号大于n的“准备型请求“。

注意条件1-1包含了条件1——每个接收者必须接受它收到的第一个提案。

&lt;blockquote&gt;
  译者注：这句话的意思是“每个接受者必须接受它收到的第一个提案”这个情形是条件1-1的一个特殊例子——因为是第一个，所以肯定没有响应过编号大于第一个编号的“准备型请求”。
&lt;/blockquote&gt;

到目前为止，我们已经有了一个完整的提案选择算法来满足系统的安全性——本质是使用了全局唯一的提案编号。最终版算法还需要在这个算法上做一点小的优化。

假设一个接受者收到了一个编号为n的“准备型请求”，而在这之前它已经响应了另一个编号大于n（假设为p）的准备型请求并承诺不再接受任何编号为n（小于p）的提案。这种情况下，接受者没有理由响应这个新收到的“准备型请求”——意味着它将不会接受编号为n的提案。因而我们需要接受者放弃这个“准备型请求”。当然了当某个提案被接受者所接受后，该提案对应的“准备型请求”也应该被丢弃——提案都接受了，这个准备阶段的请求自然也没用了。

有了这样的优化之后，一个接受者只需要记住它曾收到的最高编号的提案和它曾响应的最大编号“准备型请求”对应的编号。因为条件2-3必须被满足，而任何接受者都可能会死机，所以接受者需要持久化这些信息以便重启后进行加载。反观提案者则总是可以丢弃一个提案并且不持久化任何信息——因为它发布的提案对应的编号永远不会重复。

把提案者和接受者的行为总结在一起看，我们将会发现算法可以分为以下2个阶段：

阶段1：(a) 某个提案者选择一个提案号n，并且发送一个“准备型请求”给到系统中的大部分接受者节点。
(b) 如果一个接受者收到了一个这个编号为n的“准备型请求”，并且n大于所有它已经响应过的“准备型请求”的编号，那么它将响应这个“准备型请求”，具体的响应内容包含：承诺不再接受编号小于n的“提案”，以及它本地已经接受的编号最大的提案。

阶段2：(a) 如果一个提案者收到了来自大多数接受者节点的准备阶段的响应，然后它将把这个包含提案(n,v)的“接受型请求”发送给所有这些接受者们。它意味着这个提案是所有响应中编号最大的，或者是提案者自己组装的一个提案——来自接受者的响应中没有包含任何提案。
(b) 如果一个接受者收到了一个编号是n的“接受型请求”，除非它收到了编号大于n的“接受型请求”，否则它必须接受这个编号为n的提案。

一个提案者可以发部多种提议，只要每种提议都按照上述算法一个个的进行操作即可。提案者可以在协议运转中的任何一个时刻丢弃提议。（正确性是需要坚持的，尽管请求和/或响应会在提案被丢弃很长一段时间后到达目的地）。当整个系统中有人发出更高编号的提案时，那些发出低编号提案的提案者就该丢弃这些低编号提按。因此在接受者已经接收到更高编号“准备型请求”的前提下，当它又收到了低编号的“准备型请求”或者“接受型请求”，它应当丢弃这些请求并通知发出这些请求的提案者告诉它们目前系统中比他们发出的更高的编号，这些提案者收到后则可以放心的丢弃自己的提案。

&lt;h3 id=&quot;23-学习一个提案&quot;&gt;2.3 学习一个提案&lt;/h3&gt;

为了让整个系统中的节点学习被系统所选择的那个提案，一个学习者（learner）必须找出那个大多数节点所接受的提案。一个明显的方法是——无论何时任何接受者在接受某个提案后都需要广播给所有的学习者这个提案。这可以让学习者尽可能快的知道被选中的那个提案，但是它需要每个接受者将提案告知每个学习者——这个数字是接受者数量和学习者数量的乘积。

由于我们采用了非拜占庭错误模型，也就是假设系统中没有伪造信息的情况，所以一个学习者从另一个学习者那里学习哪个值被接受了是很简单的。我们可以让接受者把他们接受的提案发给一个指定的学习者，然后这个学习者在通知其他的学习者。这种方法需要额外的一轮通信来让所有学习者学习被选择的提案。而且这种方法也不太可靠，因为这个指定的学习者可能会宕机（单点问题）。不过这种方法有个好处是整个网络中的响应数量只是接受者和学习者节点的数量之和。

</description>
        <pubDate>Sun, 23 Dec 2018 08:23:00 +0000</pubDate>
        <link>https://tbwork.github.io/2018/12/23/simple-paxos/</link>
        <guid isPermaLink="true">https://tbwork.github.io/2018/12/23/simple-paxos/</guid>
        
        <category>paxos</category>
        
        <category>法定数量</category>
        
        
        <category>分布式算法</category>
        
      </item>
    
      <item>
        <title>浅谈微服务体系中的分层设计和领域划分</title>
        <description>&lt;h3 id=&quot;引言&quot;&gt;引言&lt;/h3&gt;

&lt;blockquote&gt;
  本文获得阿里巴巴《第二届研发效能征文》优秀文章奖，并在阿里第二届能效峰会上展出。
&lt;/blockquote&gt;

看标题感觉这个东西很理论，比起“高并发、多线程”、“分布式CAP、一致性、Paxos”、“高可用SLA”等具体的干货技术点，软件体系知识显得很“湿”，似乎人人都有自己的认识，但又很少有人能说完整，有一点可以确定的是，如果你未来需要独立设计一个复杂的系统中台，并使之未来能快速应对各种需求变化的话，科学合理的领域划分和边界界定需要我们“处女座级”的坚持下去，这对防止人力失控、减少项目烂尾很有帮助。合理的界定了边界后，即便某个微服务很糟糕，也可以就输入输出以很少的人力投入进行重构，相反的就是牵一发而动全身，加上业务需求频繁而来，很容易烂尾或是达不到如期的效果。

其实很多技术大神都是某一个技术点的好手，但可能在整体软件体系上思考并不多，每个人都有自己的设计方法，大部分容易想到的设计方法处理一般的系统已经够了，后面发生问题慢慢打补丁就行了，当我们面对各种需求变化陷入开发困境的时候我们就该想想了，咱们系统的体系设计上是否出了问题？本文不打算涉及领域建模和设计模式等代码级别的详述，而是探讨如何将一个复杂的大系统进行分层和拆分，这是设计一个优美系统的第一步，相信对各BU同事们快速搭建系统中台也是很有参考意义的。文中的一些例子大家也可能遇到过，大家如果在开发中遇到困境，可以多来圈子交流和发表问题，大家一起学习进步。大概知道内容背景的可以直接跳到第3部分。想了解一个大项目如何进行科学人员安排的可以直接看5.4部分。如果你的组里还有人把数据库模型当接口契约用，可以建议他看下5.1部分。假如你在开发过程中遇到一些别人的开发设计习惯，你觉得不是很好，但是又不知道如何说服他，都可以到评论区聊聊，大家一起讨论讨论。

&lt;h3 id=&quot;1摘要&quot;&gt;1.摘要&lt;/h3&gt;

本文阐述了一种将分层设计和DDD领域设计思想应用于微服务体系架构的方案实践，也是个人的最佳实践。对于大部分互联网公司来说，我们主张将其Web服务架构分为五层：基础设施层、领域服务层、应用服务层、网关层和用户界面层（表示层）。领域服务层和应用服务层均可以采用微服务设计进行拆分，其中领域服务层将按照DDD领域设计进行领域划分，设计为一个个领域模块微服务，每个微服务高度内聚，仅关注自己的业务，领域服务间通过接口调用进行松耦合。这种设计方案可以大大简化大系统，并且在后期的维护中优势会日渐凸显，然而把大系统分而治之拆成微服务同时也对架构师和开发人员提出了更高的要求。第2部分介绍了相关背景，接着第3部分探讨了分层设计以及每一层的功能，第4部分结合微服务和DDD对领域服务层进行服务模块划分和设计。第5部分则就分层设计和DDD领域设计中常见的问题进行了整理。

&lt;h3 id=&quot;2背景介绍&quot;&gt;2.背景介绍&lt;/h3&gt;

想写这样一篇文章很久了，虽然本科学的是软件工程，但碍于自己能力有限，从08年写代码以来一直断断续续的思考，始终对项目模块设计和分层结构设计没有一个可以让自己觉得满意且无纠结点的答案，假设了某个设计，很快在实践中又会发现其存在着一些问题。直到2014年毕业工作了解了DDD领域驱动设计后，才有了相对清晰的方向。实际上早在2004年，Eric Envas的《领域驱动设计：软件核心复杂性应对之道》就已出版，毕竟软件开发自计算机普及以来已经存在很长一段时间了，早期国外程序员对软件开发理论的研究也十分兴盛，如今成熟后反而研究的相对少了，基本上依葫芦画瓢即可。DDD领域驱动设计对软件设计各个环节的人员都有较高的要求,用《领域驱动设计》一书的话来说它需要一个“领域驱动团队”[1]，它要求从分析阶段，产品经理、项目经理、架构师以及开发工程师就使用统一的模型语言（Ubiquitous Language）来进行沟通，并且他们都懂一些代码、产品和建模相关的知识，事实上这在国内很难实施，国内的产品经理约等于需求整理工，对其计算机基础的要求是少之又少，在我所从事的公司里，也曾发生过产品经理直接指导开发，以至于后面双方理解的同一个词有着不同含义的情况。所以本文不打算去阐述DDD领域内部建模代码级别的实践，甚至本文并不认为贫血模型是不好的，本文主要探讨领域之间的划分和分层设计，正如引言说提到的，这是设计优美系统的第一步。另外提一句：其实合理设计的微服务体系中的服务本身就是功能单一边界清晰的小应用，届时贫血也好、DDD领域建模也好，其实都可以胜任。

近年来，随着分布式的发展，传统中小型机集中式服务器已经不在流行，所以微服务体系也成为了各大互联网公司主流的选择。直观的感受下&lt;strong&gt;微服务&lt;/strong&gt;和&lt;strong&gt;DDD&lt;/strong&gt;两者，似乎一个是微系统，另一个则是大系统的设计方法，似乎两者天生互斥，微服务化的小系统也用不着DDD，其实并不是，DDD是针对整个复杂的软件解决方案的一种科学设计方法，微服务化也是把复杂的大系统拆分为小系统，方便维护和管理，所以两者都有一个特点——为复杂的大系统服务。下面咱们就来探讨下，如何把DDD的领域设计和其主张的分层设计应用到微服务体系架构中。需要说明的是本文主要是个人多年来的一点总结，未必适合所有场景，有更好通用性更为广泛的方案请不吝赐教。

&lt;h3 id=&quot;3分层设计&quot;&gt;3.分层设计&lt;/h3&gt;

准确的说分层设计（Layered Architecture）跟DDD没有必然的联系，我最早接触分层设计是在携程网，当时内部使用的应该只是简单的业务层（Biz）和表示层，数据库访问之类的也是放在各自的业务包下的。后来接触和学习了《领域驱动设计：软件核心复杂性应对之道》，书的第4章“分离领域”中说到了四层分层设计，即：基础设施层、领域层、应用层和用户界面层（表示层）。DDD产生的年代微服务还未流行，当时甚至基于浏览器的Web应用都比较少，更多的是PC软件和EJB等网络应用，所以作者更多的是想表达对复杂系统的逻辑分层，并不在意每个领域是单独的系统还是一个软件系统内不同的模块。所以为了跟其做区分，我们建议的四层为在其基础上引入“服务”两个字，即：基础设施层、领域服务层、应用服务层和用户界面层。这样做的意图是让开发人员立刻可以了解到——每个领域模块即一个微服务（一个领域可以对应一个或者多个模块Module）。摘要中提到我们主张的分层体系中还有一个层，即&lt;strong&gt;网关层&lt;/strong&gt;，这又是什么鬼呢。刚刚提到的DDD的时代背景，PC软件系统或者企业内部使用的网络应用系统是根本没有网关层（有也是网络网关设备）这一说的，而现如今互联网公司产品的输出形式无外乎Web应用（网站、或者网络服务），并且为了更好的适配PC站和App，一般会采用&lt;strong&gt;前后端分离&lt;/strong&gt;的应用设计方案，这时候会产生一个需求——内部网络应用系统如何把自己的服务输出到互联网上，供外部系统或者浏览器网页访问。最直接的方式就是把应用层直接暴露在公网上，但我们不建议这么做，应用层服务更多的是关注业务应用，对网络级的系统安全性（防DDOS、钓鱼、跨域等）、请求监控等缺乏考虑，这些工作交给网关层统一管理会轻松很多（比如淘宝的TOP平台）。

这时候我们在Web应用系统中引入网关层用于衔接&lt;strong&gt;表示层&lt;/strong&gt;和&lt;strong&gt;应用层&lt;/strong&gt; ，因为这样可以更好的划分各层的职能。网关层也可以看作是应用服务层的对外包装层。如果一定要把网关层做到应用服务层里理论上也是可行的，比如针对于Spring Cloud这种框架下的微服务体系，可以考虑直接暴露应用层，只需辅助一些运维手段进行统一的安全验证和监控即可。假设我们选择引入网关层，那么我们就得到了以下网络应用系统分层体系：

&lt;img src=&quot;/image/layed-arch/layerd-architecture.png&quot; /&gt;

其中，各层的职能和作用为[2]：
&lt;ul&gt;
  &lt;li&gt;用户界面层：负责向用户显示和解释用户指令。这里指的用户可以是另一个计算机系统，不一定是使用用户界面的人（比如外部应用调用对应接口）。在全系统的视角看，通常情况下，这里指的是前端，但实际上，随着前端的日益复杂，前端也可以分为多层，那种情况另当别论。&lt;/li&gt;
  &lt;li&gt;网关层： 负责提供对外的HTTP服务或者其他网络应用层协议（这里是指OSI七层协议中的应用层，别混淆了哦）服务。该层从非业务逻辑角度对暴露到外部的接口进行鉴权、计费、风控、资源调配等操作。有些简易的系统中，改成可以合并入应用服务层中作为一个AOP存在。&lt;/li&gt;
  &lt;li&gt;应用服务层：定义软件要完成的任务，并且指挥表达领域概念的对象来解决问题。这一层所负责的工作对业务来说意义重大，也是与其他系统的应用层进行交互的必要渠道。应用层要尽量简单，不包含业务规则或者知识，而只为下一层中的领域对象协调任务，分配工作，使他们互相协作。它没有反应业务情况的状态，但是却可以具有另外一种状态，为用户或者程序显示某个任务的进度。&lt;/li&gt;
  &lt;li&gt;领域服务层：负责表达业务概念，业务状态信息以及业务规则。尽管保存业务状态的技术细节是由基础设施层实现的，但是反应业务情况的状态是由本层控制并且使用的。&lt;strong&gt;领域层是业务软件的核心。&lt;/strong&gt;&lt;/li&gt;
  &lt;li&gt;基础设施层：为上面各层提供通用的技术能力，为应用层传递消息，为领域层提供持久化机制，为用户界面层绘制屏幕组件（PS：这个在互联网应用中几乎用不到）等等。互联网Web应用系统中基础设施包含了数据持久化服务，中间件服务（数据库，Redis，Memcached，zookeeper，ELK等等）以及第三方服务等。&lt;/li&gt;
&lt;/ul&gt;

各层除了实现自己的功能外，还需要遵守以下原则：
&lt;ol&gt;
  &lt;li&gt;每一层设计保持内聚，并且只依赖于它的下方的层。&lt;/li&gt;
  &lt;li&gt;下层向上层发起的通信只能通过中间件等间接方式进行。[2]&lt;/li&gt;
  &lt;li&gt;上层和下层只能有松散耦合（各自为独立个体，通过简单引用关联）。在某些微服务框架比如Dubbo中，可以把api包提供给上层引用即可。这也符合依赖倒置原则。&lt;/li&gt;
&lt;/ol&gt;

这里重点说明应用服务层和领域服务层之间的关系。举一个我经常跟部门其他开发举的一个例子：有一家上市企业A公司，靠卖水果发家，其首席架构师科学合理的按照DDD搭建了一套基于微服务体系的卖水果应用，其架构图如下：

&lt;img src=&quot;/image/layed-arch/fruit-site.png&quot; alt=&quot;&quot; /&gt;

今年水果行情一般，而房地产十分火热，A公司高层发现房地产带动的五金行业也十分火热，于是下达任务给技术部，要求其立即着手搭建五金销售系统，货源已经谈好。得益于首席架构师之前优秀的架构设计，他发现只需要做一个卖五金的网站以及另外对微服务进行微量的调整即可满足老板的需求——因为卖五金和卖水果并无本质区别，他们涉及的环节几乎一致。加入五金售卖的系统架构图如下：

&lt;img src=&quot;/image/layed-arch/metal-sale.png&quot; alt=&quot;&quot; /&gt;

可见应用服务层代表是某一个业务应用，它代表的更多的是从需求出发的应用定义，而领域服务层则是业务领域按照自身的边界进行设计的一个高内聚的服务体。应用层通过协调和组合各个领域服务即可形成一个新的应用服务。《领域驱动设计》中明确指出，在设计领域服务时无需考虑表示层和持久层服务的东西。我在现实开发中总是遇到大量工程师按照产品的设计稿一溜烟的从上至下设计应用层服务和领域层服务，完全没有考虑业务领域的概念，导致后面微服务数量膨胀，功能重复度高。这种开发习惯代表的是《领域驱动设计》作者极力吐槽的一种模式——&lt;strong&gt;SMART UI “反模式”&lt;/strong&gt;[5]。

&lt;h3 id=&quot;4领域划分和微服务化&quot;&gt;4.领域划分和微服务化&lt;/h3&gt;

根据DDD理论，领域建模主要发生在领域服务层，各领域模块都应该是高内聚低耦合的，具有清晰的业务边界。本文不打算讨论具体的DDD建模（服务，工厂，仓库，实体，值对象，聚合等），这需要对DDD有较深入的研究，就目前所从事过的公司来看，似乎没有一家真正严格按照DDD进行项目代码设计的，就像摘要中说的，这对整个软件工程链路上的人员都有较高的要求。有机会可以单独写一篇关于自己对DDD建模的思考和建议，本文更多的是讨论高视角下的领域服务拆分，从而搭建一个低耦合高内聚的微服务体系。如果一定要将微服务和DDD联系起来的话，领域层的微服务就对应了DDD中的领域模块Module，每个Module由多个Service模式对象以及对应的模型对象（实体, 值对象以及它们的聚合）组成。

&lt;blockquote&gt;
  从《领域驱动设计：软件核心复杂性应对之道。》中我学到的主要有两块：领域设计思想和领域建模模式。本文更多的是对前者的运用，后者的对立模式是贫血模型，大家日常用到的也都是贫血模型，我也觉得贫血模型有存在的必要性，所以本文我们主要从其中借鉴一下领域设计思想。本文所描述的设计理念，并不影响具体的模型设计方法，我们仍然可以在每个微服务中使用DDD领域建模。
&lt;/blockquote&gt;

如何切分领域模块并没有一个明确的规则，不同的场景下可能相同的业务块边界也不尽相同。这里提几点领域划分的个人心得：
&lt;ul&gt;
  &lt;li&gt;领域设计一定要有清晰的功能边界。一个领域服务对应了一个功能集合，这些功能一定是有一些共性的。比如，订单服务，那么创建订单、修改订单、查询订单列表，一般是订单域的功能集合。&lt;/li&gt;
  &lt;li&gt;领域拆分并不是一步到位的，应当根据实际情况逐步展开。从单体应用到微服务体系的拆分过程能很好的说明这个问题，一上来拆的很细的改造方案一定会死的很惨。所以如果一开始不知道应该划分多细，完全可以先粗粒度划分，然后随着需要，初步拆分。比如一个电商一开始索性可以拆分为商品服务和交易服务，一个负责展示商品，一个负责购买支付。随后随着交易服务越来越复杂，就可以逐步的拆分成订单服务和支付服务。&lt;/li&gt;
  &lt;li&gt;领域拆分并不是一成不变的，应当具体情况具体分析。2015年在大众点评的时候，其订单服务就拆分为了order-service和order-query-service，一来为了读写分离，二来order-query-service作为单独应用可以按需水平扩容。&lt;/li&gt;
  &lt;li&gt;领域可以是多个子领域的一个虚拟集合，换句话说多个微服务也可以形成一个大域，不必纠结于领域和微服务之间的数量对应关系。我们在做架构设计PPT的时候可能就把订单域作为一个领域，代表了这个域就是关于订单的，具体该有几个微服务，这需要更细的详细设计来提供。&lt;/li&gt;
  &lt;li&gt;领域层服务设计应当是调用者无关的。这一点有点像第一点，但是它强调的是领域层服务的设计不应该受调用者的影响，这个观点在《领域驱动设计：软件核心复杂性应对之道》这本书里也可以找得到[4]。领域层服务开发和设计的理念是关注自己的域，一旦边界划分清楚了，开发所需要考虑的永远都只是输入和输出，提供的服务一定是尽可能通用的，面向功能来开发的，而不是面向调用方来开发的。比如某个调用方提出了一个需求：调用方B希望A服务提供一个买汽车的接口，那么A服务设计的接口就应该是buyCar()，而不是buyCarForB()。&lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;5qa&quot;&gt;5.Q&amp;amp;A&lt;/h3&gt;

&lt;h4 id=&quot;51-能不能在所有层使用数据持久层模型简单快捷&quot;&gt;5.1 能不能在所有层使用数据持久层模型，简单快捷？&lt;/h4&gt;

大家一定听说过不同层的数据模型的叫法不同的概念，比如数据持久层的模型对象叫DBO（database object）或者DPO（data persistence object),领域层的模型对象叫DMO（Domain Model Object）或者就叫Model，数据传输层的模型对象叫DTO（Data Transfer Object)。那为啥要这么多模型呢，直接使用Mybatis等ORM框架生成DBO，然后一路吐给前端不是更爽（还真有同事尝试立项写Mybatis插件来实现这种所谓的代码自动化）。我个人建议如果您真的是要搭建一个复杂的大系统，大平台，一定不要偷这种懒，最好的就是做到”一层一模型”（网关层使用应用层模型即可）。各层之间采用手动的数据赋值（getter，setter）来完成，或者使用一些转换框架来简化转换代码，个人在用getter/setter时感觉并不会耽误什么，在一个个set的时候，恰好可以对模型的字段细节进一步确认，并且拒绝使用BeanUtils.copyProperties()这种工具类，因为这样的工具类会让”一层一模型”形同虚设，开发会热衷于把DPO拷贝到领域中换个名字以保证可以用拷贝工具。下面我们来细谈下不能在每一层都是用数据持久层模型的具体原因：
&lt;ul&gt;
  &lt;li&gt;应用层对接网关层，是向面向C端或者调用者的一个数据出口，但是调用者只需要这个出口输出用户感兴趣的数据，并且有些敏感数据不能吐出去。如果应用层（面向调用者）使用的仍然是数据库模型，而开发人员没有在应用层把无关值置空的话（相信我，需求一多，工作一忙，鬼才会在意这些细节），那么数据库里的整条记录就作为接口输出吐出去了。比如订单记录，用户订单列表可能只需要订单ID，商品名称，订单金额。而像商家结算价这种就不能吐出去，万一被有心人察觉到了，用户一定会投诉——你跟商家结算价200，卖给我400？&lt;/li&gt;
  &lt;li&gt;前端或者接口调用方会很痛苦，一个接口契约多一两个无关字段是没关系的，但是一个契约里给的30个字段，我只用到5个，前端会骂娘的，我亲眼见过这种事，设计原则里有个原则叫”迪米特法则”，也叫最小知识原则，接口设计也可以参考这个原则，尽量让你的调用方知道尽可能少的信息点就能完成相关的任务。&lt;/li&gt;
  &lt;li&gt;“一层一模型”本质是解耦模型依赖。我在上家公司做架构师时为了兼顾开发的感受，决定让他们可以在领域层和基础设施层都是用数据持久层模型，而只需要在应用层做数据控制（解决第一个问题），然而我的妥协也慢慢露出弊端，开发有时候觉得某个数据库字段命名不合适修改之后，整个引用了该模型的微服务都需要修改，如果一层一模型的话，只需要关联数据库访问的服务修改下DPO和DM的映射就行了，其他上层微服务都是依赖DM的。虽然我们不鼓励随意改动数据库字段，但设计框架上最好能支持这种情况。&lt;/li&gt;
&lt;/ul&gt;

刚开始推广”一层一模型”的时候，会有耍小聪明的开发去把下一层的模型POJO直接拷贝过来改个名字，然后用BeanUtils.copyProperties()完成赋值，这样跟直接使用数据持久层模型就没有区别了，所以要杜绝这种情况的发生。

&lt;h4 id=&quot;52-为啥需要应用层领域层微服务直接通过网关暴露不就行了吗&quot;&gt;5.2 为啥需要应用层，领域层微服务直接通过网关暴露不就行了吗？&lt;/h4&gt;

对于习惯了单体应用开发者来说，一个微服务很可能就直观对应成了一个个垂直的应用服务，每个服务间的关系是这样的：
&lt;img src=&quot;/image/layed-arch/multi-app-arch.png&quot; alt=&quot;&quot; /&gt;
其实这样的体系本质上仍然不能解决软件的复杂性，这只是把系统简单粗暴的拆分了，耦合问题仍然很严重，甚至这很有可能比原来的单体应用更复杂（多对多依赖），如果使用微服务体系来处理复杂系统，其服务体系应当是这样的：
&lt;img src=&quot;/image/layed-arch/micro-service-arch.png&quot; alt=&quot;&quot; /&gt;

&lt;blockquote&gt;
  这两幅图的区别在于，其实第一幅图中的每个服务都包含了完整的2～3层，所以不再需要单独的应用层。而第二幅图各个领域模块互相协作，对外提供服务时，则需要有一层直面用户需求的应用层。
&lt;/blockquote&gt;

达成了微服务体系是解决复杂系统的出路之一这个共识后，我们再来看”应用层服务存在的必要性”有哪些理由：
&lt;ul&gt;
  &lt;li&gt;&lt;strong&gt;统一权限校验&lt;/strong&gt;：如上文所说，网关层只负责网络级的安全防护，业务层的权限校验则需要应用层来完成，试想一个没有应用层的微服务体系，就意味着每一个微服务都需要加上权限校验逻辑，这不仅编码上困难（可以用过滤器，AOP），而且对于成千上万个微服务（据了解，腾讯目前微服务数量已经超过2万，大众点评有将近千个微服务）来说，这会浪费大量时间，调用链越长，浪费的时间越多。换句话说，微服务体系有一个不突出但是很重要的特征—— &lt;strong&gt;领域间环境安全，领域间的通信应当是可信的&lt;/strong&gt; ，否则分布式的缺点（多服务意味着多次通信）会被加剧。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;业务数据网关&lt;/strong&gt;：举个例子，一个order-service提供了一个queryOrder的接口，输入起始日期查询对应的订单列表，其有2个消费者：&lt;strong&gt;C端网站应用服务&lt;/strong&gt; 和 &lt;strong&gt;报表应用服务&lt;/strong&gt; ，&lt;strong&gt;C端网站应用服务&lt;/strong&gt; 只需要知道订单的基本信息如下单时间、商品名称、金额就可以了，而报表应用服务是给管理者看的，需要的订单数据很全，除了&lt;strong&gt;C端网站应用服务&lt;/strong&gt;需要的之外，还需要看平台与商家的结算金额。根据第4部分最后一点的思路，我们肯定不能为调用方写定制接口（写不完的，有的要这个数据，有的要那个数据，每次新增调用方，领域服务还得找人修改）。而如果我们统一使用的全量数据，并且没有应用层（同样的也没有应用层模型DTO了），那么很可能我们吐出去的数据包含了我们与商家的结算价，这会引发很多不必要的麻烦的。所以应用层还充当了业务数据网关的作用，应用层应用服务需要保证仅吐出调用方感兴趣的数据。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;资源控制和缓存&lt;/strong&gt;：想象一下双十一高并发的情况，如果查询库存每次都查库是多么恐怖的一件事。所以一般仅在支付的时候做一次库存校验，而在商品展示时查缓存的库存即可。那么问题来了，如果没有应用层，缓存直接放在库存微服务上是否可行呢？首先这会入侵库存领域，库存微服务需要按照调用方的需求做特定时间的缓存，而不是自己想缓存多久就多久，我想库存微服务的开发者也会很不满的，他会提出，让你自己去做缓存。他的方案是科学的，因为还有一些其他服务可能需要实时的数据。这时候就需要有一层来做对其下方微服务返回的数据按照应用自身的需求进行必要的缓存，而不是把这些需求都推给资源提供方，想象一下一个资源提供方有多少需求者，每个需求方都有自己的定制需求，该多痛苦。当然这一点也不是说微服务自身不能做缓存，微服务自身的缓存一定是考虑自身域的合理性后的一个措施（比如订单查询服务会做一个500ms的缓存，因为不会有正常人500ms里点两次查询还必须要求两次都是最新的），而不是由调用方来决定的。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;资源聚合和加工&lt;/strong&gt;：其实第2点也有加工的味道在里面，只是这里更多的是描述应用层应用根据自身需求来对下层返回的数据进行聚合和处理的过程。举个例子就能很好的说明这一点：任何APP都有首页，而首页的数据可能是五花八门的，可以有用户昵称、最近下的订单简要信息、最近支出曲线、积分信息等。这4个信息可以来自4个领域微服务，他们是：用户中心、订单中心、支付中心和积分中心。那么有读者会说，直接暴露微服务让前端分别调用4个接口再做聚合不是也行吗？显然这种粗暴的方式是极其不合理的，会额外增加广域网网络调用3次不说，还传输了很多不必要的信息。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;应用隔离和流控&lt;/strong&gt;：如果将每个领域服务直接暴露到网关层对外提供服务，那么在多应用场景下，多个应用间是共享这些服务能力的，在服务降级的时候，如果需要按照应用进行降级（比如将优先级不高的应用进行限流），就很难实现。但如果每个应用对应了一个应用层服务，只需要对其暴露的网关接口进行统一限流就行了，或者在应用层做一个开关，将其流量阻止在应用层，而不是拖垮整个领域服务。举个例子，假如我们的平台不仅有自己的网站服务，还有第三方的对接服务，如果某个第三方被攻击而我们直接将领域服务暴露了出去，那么我们就需要在各个领域层服务里去编写对应的开关，这将侵入领域层服务，导致不必要的耦合。而有了应用层这些都不是问题，因为应用层充当了一个调度者的角色，调度者可以很轻松的决定是否调度下层的服务。&lt;/li&gt;
&lt;/ul&gt;

为了加深对应用层的理解，我们举个代码的例子，假如我们写一个很简单的首页应用：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;Response getHomeData(Request request){

    String nickName = userService.getNickName(request.getUserId()); 
    OrderInfo orderInfo = orderService.queryLatestOrder(request.getUserId());
    CostTrend costTrend = payService.queryCostTrend(request.getUserId());
    Integer points = pointService.queryAvailablePoints(request.getUserId());
    return new Response(nickName, orderInfo, costTrend, points);
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
这里的4个服务类实例userService，orderService、payService和pointService如果都是本地的方法，那么这就是一个单体应用，而微服务化后这4个可能都是微服务了，但是应用层应用的结构还是可以不用变化（现在很多的RPC框架都做到了与调用本地方法无差别）。这就是应用层的位置所在。

&lt;h4 id=&quot;53-什么是反模式&quot;&gt;5.3 什么是反模式？&lt;/h4&gt;

这里的反模式是指《领域驱动设计：软件核心复杂性应对之道》这本书里提到的与DDD相违背的模式，也是Eric极其反对的一种模式，即SmartUI模式（注意反模式不等于SmartUI，只是在本书中作为一个反模式的例子而已），这是一种什么样的模式呢，其实我很早之前做C++ Builder（和Delphi很像）的时候还不知道，C++ Builder就是一种SmartUI模式。但其实SmartUI并没有错，对于小规模的PC本地应用开发来说也是有很多好处的。举个例子，C++ Builder中在窗体上添加一个按钮，然后双击按钮添加事件，这样就跟实际操作的时候有机的结合了起来。换句话说就是使用界面驱动业务开发。在大型系统的开发上，这种模式是害人精，我很理解Eric为啥这么讨厌它。曾有一次我带领着一个团队做封闭式开发，在过完产品需求后，家里出了点事我请了几天假，回来后发现产品经理竟然指挥让开发按照UI原型来设计数据库，我审核的时候发现这些开发设计的表有极其多的冗余，而有一些重要的过程变量值却没有考虑到。比如他们会为每个页面建几个表，这显然是行不通的，科学的方法是拆分领域，每个领域自己建立自己的表。UI只是应用层整合了各领域服务的数据并且处理后输出的一种展示。

&lt;h4 id=&quot;54-分层设计的开发步骤是怎样的&quot;&gt;5.4 分层设计的开发步骤是怎样的？&lt;/h4&gt;

假设我们以一个标准的SaaS项目为主，也就是表示层是前端页面（可以是APP，H5，M站，小程序，PC站等），那么高效的一种开发步骤可以是这样的：
&lt;ol&gt;
  &lt;li&gt;业务、产品、开发PM进行需求评审（可行性等）&lt;/li&gt;
  &lt;li&gt;产品准备好原型&lt;/li&gt;
  &lt;li&gt;产品、开发（前后端）、架构师（或有架构师能力的资深开发）开会过PRD，了解要做什么&lt;/li&gt;
  &lt;li&gt;架构师开始设计领域（资深架构师一下午就能搞定），前端开始切图，应用层开发开始按照UI和PRD设计前端每个页面使用的Restful接口（比如直接Springfox代码生成Swagger）&lt;/li&gt;
  &lt;li&gt;架构师设计完领域后分工给领域层开发，进行领域边界明确，然后领域层开发开始设计数据库表等。&lt;/li&gt;
  &lt;li&gt;这样前后端开发就同时开工了。&lt;/li&gt;
  &lt;li&gt;开发初步完成后，自测加连调。&lt;/li&gt;
  &lt;li&gt;后续就是测试发布了。&lt;/li&gt;
&lt;/ol&gt;

具体阶段和时间线可以参考下图：

&lt;img src=&quot;/image/layed-arch/develop-sequence.png&quot; alt=&quot;&quot; /&gt;

&lt;h3 id=&quot;6结语&quot;&gt;6.结语&lt;/h3&gt;

真实技术开发日常讨论的经常是高并发、多线程、大数据，分布式、RPC，很少有人讨论软件架构设计方面的，架构师文化不应该只是对某个技术点的深入挖掘，也应该多讨论些大型软件设计理念方面的～
欢迎大家有任何软件/系统/平台设计方法方面的问题一起来留言区探讨～

&lt;h3 id=&quot;参考文献&quot;&gt;参考文献&lt;/h3&gt;
&lt;ol&gt;
  &lt;li&gt;领域驱动设计：软件核心复杂性应对之道。&lt;strong&gt;Eric Envas&lt;/strong&gt;，2016年6月第二版，前言部分。&lt;/li&gt;
  &lt;li&gt;领域驱动设计：软件核心复杂性应对之道。&lt;strong&gt;Eric Envas&lt;/strong&gt;，2016年6月第二版，Page.44。&lt;/li&gt;
  &lt;li&gt;领域驱动设计：软件核心复杂性应对之道。&lt;strong&gt;Eric Envas&lt;/strong&gt;，2016年6月第二版，Page.45。&lt;/li&gt;
  &lt;li&gt;领域驱动设计：软件核心复杂性应对之道。&lt;strong&gt;Eric Envas&lt;/strong&gt;，2016年6月第二版，Page.46。&lt;/li&gt;
  &lt;li&gt;领域驱动设计：软件核心复杂性应对之道。&lt;strong&gt;Eric Envas&lt;/strong&gt;，2016年6月第二版，Page.48。&lt;/li&gt;
&lt;/ol&gt;

&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#引言&quot; id=&quot;markdown-toc-引言&quot;&gt;引言&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#1摘要&quot; id=&quot;markdown-toc-1摘要&quot;&gt;1.摘要&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#2背景介绍&quot; id=&quot;markdown-toc-2背景介绍&quot;&gt;2.背景介绍&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#3分层设计&quot; id=&quot;markdown-toc-3分层设计&quot;&gt;3.分层设计&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#4领域划分和微服务化&quot; id=&quot;markdown-toc-4领域划分和微服务化&quot;&gt;4.领域划分和微服务化&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#5qa&quot; id=&quot;markdown-toc-5qa&quot;&gt;5.Q&amp;amp;A&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#51-能不能在所有层使用数据持久层模型简单快捷&quot; id=&quot;markdown-toc-51-能不能在所有层使用数据持久层模型简单快捷&quot;&gt;5.1 能不能在所有层使用数据持久层模型，简单快捷？&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#52-为啥需要应用层领域层微服务直接通过网关暴露不就行了吗&quot; id=&quot;markdown-toc-52-为啥需要应用层领域层微服务直接通过网关暴露不就行了吗&quot;&gt;5.2 为啥需要应用层，领域层微服务直接通过网关暴露不就行了吗？&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#53-什么是反模式&quot; id=&quot;markdown-toc-53-什么是反模式&quot;&gt;5.3 什么是反模式？&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#54-分层设计的开发步骤是怎样的&quot; id=&quot;markdown-toc-54-分层设计的开发步骤是怎样的&quot;&gt;5.4 分层设计的开发步骤是怎样的？&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#6结语&quot; id=&quot;markdown-toc-6结语&quot;&gt;6.结语&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#参考文献&quot; id=&quot;markdown-toc-参考文献&quot;&gt;参考文献&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
        <pubDate>Thu, 25 Oct 2018 05:29:18 +0000</pubDate>
        <link>https://tbwork.github.io/2018/10/25/layed-dev-arch/</link>
        <guid isPermaLink="true">https://tbwork.github.io/2018/10/25/layed-dev-arch/</guid>
        
        <category>DDD</category>
        
        <category>领域</category>
        
        <category>分层设计</category>
        
        <category>Layered-Architecture</category>
        
        
        <category>架构师</category>
        
      </item>
    
      <item>
        <title>JVM运行时内存数据区域</title>
        <description>&lt;h2 id=&quot;1-讨论背景&quot;&gt;1 讨论背景&lt;/h2&gt;

周志明老师写的《深入理解Java虚拟机》应该很多程序员都读过，第二章中阐述了Java虚拟机在执行Java程序的过程中是如何管理内存的，以及这些内存是如何被划分成更细的逻辑区域的。如下图所示，按照书中的论述JVM运行时数据区域包含以下几个数据区[1]。

&lt;img src=&quot;/image/java-memory-parts/parts-in-book.png&quot; alt=&quot;&quot; /&gt;

按照《Java虚拟机规范（Java SE 7版）》，各区域的功能简要介绍如下：
&lt;ul&gt;
  &lt;li&gt;&lt;strong&gt;程序计数器&lt;/strong&gt;：各线程私有。用于记录每个线程下一条待执行的字节码指令以及相关信息。这是唯一的不会抛出OOM异常的区域。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Java虚拟机栈&lt;/strong&gt;：各线程私有。虚拟机栈由一个个的栈帧组成，每个栈帧包含了对应方法执行所需要的信息，具体包括：局部变量表、操作数栈（类似于编译型语言体系下的数据寄存器）、动态链接（某些接口符号可能会动态的指向不同的目标方法）、函数返回地址以及其他一些相关信息。理论上当函数调用链超过栈的深度时就会触发StackOverflow，当该区域设置为动态扩展时，虚拟机无法为栈申请到更多内存时就会触发OOM。事实中基本上不管哪种情况，结果都很可能会是StackOverflow，因为栈容量和栈帧的大小决定了栈的深度（栈帧大小*深度&amp;lt;=栈容量），所以当OOM时，栈深度一定也已经不够用了，所以抛出StackOverflow异常也无可厚非。可以通过“-Xss”来配置虚拟机栈固定大小。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Java堆&lt;/strong&gt;：各线程公有。虚拟机工作的主要内存区域（大部分情况下也是最大的），绝大部分对象实例的内存分配都在这里进行。Java 7和之前的Java堆细分为：新生代（伊甸区、存活区0、存活区1）、年老代和永久代。Java 8去除了永久代，替换以Metaspace。在JVM的运行中，大部分情况下，GC主要就发生在堆区域，&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;方法区&lt;/strong&gt;：各线程公有。用于存放类定义、常量池、静态变量（static修饰）、编译后的字节码等。方法区实际上是从堆上划分出来的一块区域，但是其GC机制是单独的，与堆不同，所以为了区分方法区和堆，通常又把方法区叫做“非堆”。方法区对应了堆中的永久代。因此在Java8以及之后版本中，永久代被抹除了，方法区也移到了元数据空间（metaspace）中。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;运行时常量池&lt;/strong&gt;：各线程公有。用于存放类信息中的常量（字面量、符号引用等），每个类编译后的信息中的都有一个常量池，可以通过javap -vebose xxxx.class命令来查看。&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;直接内存&lt;/strong&gt;：进程间公有。直接内存不属于Java虚拟机运行时数据区的一部分，它是指操作系统分配给虚拟机以及其他进程所运行的那块内存区域，之所以这么说，是因为很多服务器都是虚拟机（操作系统级别），对于物理机来说，这块内存就是指操作系统所管控的物理内存。通过在堆中创建一个DirectByteBuffer实例来对直接内存进行访问。&lt;/li&gt;
&lt;/ul&gt;

很多读者了解完这些后还是云里雾里，各论坛还是会出现各种没有定论的问题，比如
&lt;ol&gt;
  &lt;li&gt;字符串常量池属于哪个数据区？书中对字符串常量池和运行时常量池描述的相当晦涩和模糊。&lt;/li&gt;
  &lt;li&gt;Java6、Java7和Java8的运行时内存数据区域到底有何不一样？&lt;/li&gt;
  &lt;li&gt;什么是字面量，什么又是字符串常量？&lt;/li&gt;
  &lt;li&gt;什么是&lt;strong&gt;本地内存&lt;/strong&gt;？他和&lt;strong&gt;直接内存&lt;/strong&gt;相同嘛？什么又是&lt;strong&gt;堆外内存&lt;/strong&gt;？&lt;/li&gt;
&lt;/ol&gt;

下面我们围绕这几个问题做一些讨论和引申，从而帮助我们更好的理解运行时数据区域划分。

&lt;h2 id=&quot;2-字符串常量池&quot;&gt;2 字符串常量池&lt;/h2&gt;

我们先来回答第一和第二个问题。

&lt;h3 id=&quot;21-字符串常量池在哪&quot;&gt;2.1 字符串常量池在哪&lt;/h3&gt;

在不同的Java版本中，规范规定的字符串常量池的位置也不一样。以下三张图分别代表了Java6、Java7和Java8体系下的Java虚拟机与运行时数据区域划分，哪些是线程私有，哪些是线程公有，哪些又是进程间公有都比较清晰了。

&lt;h4 id=&quot;211-java-6-虚拟机运行数据区&quot;&gt;2.1.1 Java 6 虚拟机运行数据区&lt;/h4&gt;

&lt;img src=&quot;/image/java-memory-parts/java6.png&quot; alt=&quot;Java 6 内存数据区域划分&quot; /&gt;

当我们听到“字符串常量池也是方法区的一部分”的时候，我们要知道他大概暗指的是Java 6或者之前的版本。如上图所示，在Java 6虚拟机规范中，字符串常量池确实是方法区的一部分，受永久代内存区大小的限制。当频繁使用Spring.intern()时，可能会引发OOM（PermGen space)。

&lt;h4 id=&quot;212-java-7-虚拟机运行数据区&quot;&gt;2.1.2 Java 7 虚拟机运行数据区&lt;/h4&gt;

&lt;img src=&quot;/image/java-memory-parts/java7.png&quot; alt=&quot;Java 7 内存数据区域划分&quot; /&gt;

从Java 7 开始，规范将&lt;strong&gt;字符串常量池&lt;/strong&gt;迁移到了&lt;strong&gt;Java堆&lt;/strong&gt;中，受Java堆大小的限制。当频繁大量使用String.intern()时，可能会引发OOM(Java heap space)。

&lt;h4 id=&quot;213-java-8-虚拟机运行数据区&quot;&gt;2.1.3 Java 8 虚拟机运行数据区&lt;/h4&gt;

&lt;img src=&quot;/image/java-memory-parts/java8.png&quot; alt=&quot;Java 8 内存数据区域划分&quot; /&gt;

Java 8 虚拟机规范彻底移除了永久代（-XX:Permsize和-XX:MaxPermsize均已失效），替而代之的则是&lt;strong&gt;元空间(Metaspace)&lt;/strong&gt;。&lt;strong&gt;字符串常量池&lt;/strong&gt;仍然在&lt;strong&gt;Java堆&lt;/strong&gt;中，但方法区已经迁移到了元空间中。这时候由于滥用 String.intern()引发的OOM依旧在Java堆中。

&lt;h3 id=&quot;22-字符串常量池是啥&quot;&gt;2.2 字符串常量池是啥&lt;/h3&gt;

那么字符串常量池的数据结构是怎么实现的呢？答案是HashMap，每个字符串常量池对应了一个StringTable的数据结构，其本质并不是Table，而是一个HashMap。这个HashMap的容量是固定的（默认1009），可以通过&lt;strong&gt;-XX:StringTableSize&lt;/strong&gt;来设置，注意这个值是指哈希表中桶的数量，不是占用内存的大小。所以这个值最好是一个质数，并且要大于默认的1009[2]。

&lt;h2 id=&quot;3-字面量和字符串常量&quot;&gt;3 字面量和字符串常量&lt;/h2&gt;

如以下代码：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;String str = &quot;123&quot;;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
其中”123”就是我们经常看到的“字面量”。字面量是随着Class信息等在类被加载完毕后一起进入&lt;strong&gt;运行时常量池&lt;/strong&gt;的。
而
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;String str2 = str.intern();
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
这句代码则尝试将str的值放入字符串常量池，然而”123”已经在类信息的常量池中了，所以StringTable实际记录的是类信息常量池中该字符串的引用。

对于语句：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;String str = new StringBuilder(&quot;hello&quot;).append(&quot; world&quot;).toString().intern();
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
这会将新创建的“hello world”的堆内对象引用（str）放入到&lt;strong&gt;字符串常量池&lt;/strong&gt;中，因为这是第一次出现，没有其他地方存在该值的引用。

&lt;h2 id=&quot;4-本地内存和直接内存&quot;&gt;4 本地内存和直接内存&lt;/h2&gt;

首先需要说明的是，&lt;strong&gt;本地内存&lt;/strong&gt;(Native Memory)和&lt;strong&gt;堆外内存&lt;/strong&gt;(Off-heap Memory)的含义是一样的。而关于&lt;strong&gt;直接内存&lt;/strong&gt;和&lt;strong&gt;本地内存&lt;/strong&gt;的关系，StackOverflow上也没有说清楚的帖子，第二部分中的三张图已经可以很好的说明直接内存和本地内存的关系了，所谓的本地内存是操作系统分配给JVM虚拟机（作为一个进程）使用的内存块中除去堆的那一部分。而直接内存则是所有进程共享的操作系统所控制的内存。所以可以这么说：本地内存和直接内存的关系就像“苹果”和“水果”的关系，苹果属于水果，是水果更具体的限定。Java8中的元空间就属于本地内存空间，而他们都是直接内存的一部分。
通过DirectByteBuffer分配的内存区域一定在本地内存中,它也受直接内存大小的限制。本地内存的大小也有限制，比如Window中对每个程序运行所需的内存大小做了2G的默认限制，这只时候其上运行的JVM的本地内存大小≈2G-JVM堆内存大小。

&lt;h2 id=&quot;5-字符串常量池所属数据区的具体说明&quot;&gt;5 字符串常量池所属数据区的具体说明&lt;/h2&gt;

下面我们举2个例子讨论下在Java6和Java7（含之后版本）下字符串常量池迁移带来的变化

&lt;h3 id=&quot;51-例子1&quot;&gt;5.1 例子1&lt;/h3&gt;

请给出以下代码抛出异常的类型：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;import java.util.ArrayList;
import java.util.List;

public class Test {  
	  public static void main(String[] args){  
		  List&amp;lt;String&amp;gt; list = new ArrayList&amp;lt;String&amp;gt;();
		  int i = 0;
		  while(true) { 
			   list.add( String.valueOf(i++).intern());
		  }
	  }
}

&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
然后启动参数中我们加上：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;-XX:PermSize=10M -XX:MaxPermSize=10M
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
分析下这个代码，其意图在于不断的产生新的字符串，并且放入&lt;strong&gt;字符串常量池&lt;/strong&gt;中，试图撑爆永久代。然而这只会在Java 6 中发生，对于Java7和Java8来说，字符串常量池已经迁移到了&lt;strong&gt;Java堆&lt;/strong&gt;中，如果这时候我们添加以下虚拟机参数：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;-Xms10M -Xmx10M
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
则会引发：java.lang.OutOfMemoryError: GC overhead limit exceeded 这样的错误，这个异常的本质与 OOM(Heap space)一直，都是堆内存溢出。

&lt;h3 id=&quot;52-例子2&quot;&gt;5.2 例子2&lt;/h3&gt;

以下代码在Java6和Java7中输出也不相同：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;
public class TestStringConstantPool {

	public static String hello = &quot;Hello Java&quot;;
	
	public static void main(String[] args) {
		 
		String str1 = new StringBuilder(&quot;Hello &quot;).append(&quot;World&quot;).toString();
		System.out.println(str1.intern() == str1);
		
		String str2 = new StringBuilder(&quot;Hello &quot;).append(&quot;Java&quot;).toString();
		System.out.println(str2.intern() == str2); 
	}
} 

&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
在Java6中会输出：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;false
false
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
在Java7中则输出：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt; true
 false
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
首先我们分析下Java6中的场景，Java6中字符串常量池还是运行时常量池的一部分，所以使用String.intern()时，会把堆中的字符串复制到方法区中，返回的是方法区中的对象引用。所以不管如何，堆中对象和方法区中对象应用都不会想等。
 而在Java7中，这个情况发生了变化，字符串常量池转移到了堆中，对于&lt;strong&gt;str1&lt;/strong&gt;来说，字符串常量池StringTable会记录其在堆中的引用（即str1）。所以&lt;strong&gt;str1.intern() == str1&lt;/strong&gt;成立。而&lt;strong&gt;str2&lt;/strong&gt;情况则不一样了，因为&lt;strong&gt;“Hello Java”&lt;/strong&gt;字符串已经存在于方法区的运行时常量池中，所以intern()返回的是方法区中的对象引用。所以&lt;strong&gt;str2.intern() == str2&lt;/strong&gt;不成立。

&lt;h2 id=&quot;参考文献&quot;&gt;参考文献&lt;/h2&gt;
&lt;ol&gt;
  &lt;li&gt;深入理解Java虚拟机。&lt;/li&gt;
  &lt;li&gt;http://java-performance.info/string-intern-in-java-6-7-8/&lt;/li&gt;
&lt;/ol&gt;

&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#1-讨论背景&quot; id=&quot;markdown-toc-1-讨论背景&quot;&gt;1 讨论背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#2-字符串常量池&quot; id=&quot;markdown-toc-2-字符串常量池&quot;&gt;2 字符串常量池&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#21-字符串常量池在哪&quot; id=&quot;markdown-toc-21-字符串常量池在哪&quot;&gt;2.1 字符串常量池在哪&lt;/a&gt;        &lt;ul&gt;
          &lt;li&gt;&lt;a href=&quot;#211-java-6-虚拟机运行数据区&quot; id=&quot;markdown-toc-211-java-6-虚拟机运行数据区&quot;&gt;2.1.1 Java 6 虚拟机运行数据区&lt;/a&gt;&lt;/li&gt;
          &lt;li&gt;&lt;a href=&quot;#212-java-7-虚拟机运行数据区&quot; id=&quot;markdown-toc-212-java-7-虚拟机运行数据区&quot;&gt;2.1.2 Java 7 虚拟机运行数据区&lt;/a&gt;&lt;/li&gt;
          &lt;li&gt;&lt;a href=&quot;#213-java-8-虚拟机运行数据区&quot; id=&quot;markdown-toc-213-java-8-虚拟机运行数据区&quot;&gt;2.1.3 Java 8 虚拟机运行数据区&lt;/a&gt;&lt;/li&gt;
        &lt;/ul&gt;
      &lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#22-字符串常量池是啥&quot; id=&quot;markdown-toc-22-字符串常量池是啥&quot;&gt;2.2 字符串常量池是啥&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#3-字面量和字符串常量&quot; id=&quot;markdown-toc-3-字面量和字符串常量&quot;&gt;3 字面量和字符串常量&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#4-本地内存和直接内存&quot; id=&quot;markdown-toc-4-本地内存和直接内存&quot;&gt;4 本地内存和直接内存&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#5-字符串常量池所属数据区的具体说明&quot; id=&quot;markdown-toc-5-字符串常量池所属数据区的具体说明&quot;&gt;5 字符串常量池所属数据区的具体说明&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#51-例子1&quot; id=&quot;markdown-toc-51-例子1&quot;&gt;5.1 例子1&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#52-例子2&quot; id=&quot;markdown-toc-52-例子2&quot;&gt;5.2 例子2&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#参考文献&quot; id=&quot;markdown-toc-参考文献&quot;&gt;参考文献&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
        <pubDate>Sat, 20 Jan 2018 13:49:08 +0000</pubDate>
        <link>https://tbwork.github.io/2018/01/20/java-memory-parts/</link>
        <guid isPermaLink="true">https://tbwork.github.io/2018/01/20/java-memory-parts/</guid>
        
        <category>虚拟机栈</category>
        
        <category>方法区</category>
        
        <category>Java堆</category>
        
        <category>运行时常量池</category>
        
        
        <category>JVM</category>
        
      </item>
    
  </channel>
</rss>
