本人计算机硕士毕业，先后在三家厂工作，工作节奏虽说不是 007 吧，但偶尔 996 是有的，勤勤恳恳搬砖是常态，也偶尔累了就划划水摸鱼。在这行业不焦虑是假的，35 岁危机时刻提醒着每一位年轻的程序员，这行主打一个精神内耗。

前几年互联网飞速发展高薪招人时，大家都有肉吃，现在遇到互联网寒冬了，有汤喝就不错了，尤其对晚入行的95 后社畜，现在回过头看，已经是互联网红利退潮的末期了。对于 80 后早一批入行的程序员， 肯定钱也挣够了，房子也早就翻几倍了，早就有抗御风险的能力了，即使裁员了也能拿着分手费找个差不多的厂子继续苟着。但是对于 95 后来说，惨不忍睹，行业内卷及其严重，刚有点工作经验就遭遇大规模裁员，重点买房都是踩在最高点接盘，现在房价跌了，车子打价格战，直接把前几年辛辛苦苦挣的首付跌没了，这几年白干了，说起来，心就抽搐的疼。不像人家00 后，直接看开了，不破三个 dai，房贷，车贷和传宗接代，直接卷老家公务员躺平，享受人生，逃离大城市的拥挤，拒绝被房子的套牢。

金融危机，经济下行，行业越来越卷，精神内耗极其严重，身体健康堪忧。我突然顿悟了，我决定，为自己而活。想看世界的心也越来越强烈，最后我坐不住了，做了个大胆的决定，畅游中国。刚好疫情快结束时，航空公司推出了自己的产品，畅游中国随心飞，我立刻入手了，入手价是三千多点，全国飞不限次数。我一边安排好自己的时间订机票，一边计划旅行路线，一个女生独自环游中国之旅开始了。没有队友，不给生活中任何糟心事打断我的计划，一人吃饱，全家不饿。下面给大家说说我去了哪些地方。

贵州-贵阳

我看好时间后立刻定机票，从上海飞到了贵阳，准备打卡黄果树瀑布。我定的酒店就在黄果树景点附近不远，一大清早7点我就起床了，呼吸着让人神清气爽的空气，吃了一些自己带的进口苹果作为早餐，特别甘甜，饱腹感足足的。8点进山了，那一刻，我别提多开心了。

回想起当社畜时，每次都是8.30起床，9.30左右到公司，每天上班心情比上坟都沉重，永远干不完的KPI，OCR，不是被PUA就是吃老板画的大饼，再丰盛的早餐一想到一堆任务要做，吃着也如同嚼蜡，更别提神清气爽，心境开拓了。

在进入黄果树后，我欢快的脚步往前走，因为我是一个女孩子独行，所以不太愿意跟陌生人说话，一路上虽然很沉默，但看到这些壮观的自然景色，闻着草木花果香，内心激动不已。爬了一个钟左右的山，终于看到了大瀑布。

下面是我实拍的景点图：

有句古诗，疑似银河落九天，一路好山好水，逛完黄果树后我出来就去吃了贵州的特色菜，价格美丽，味道很不错，超级喜欢，
当时就在感慨，上海要是能吃到这么好吃又鲜美的酸汤鱼就好了。

重庆

本来下一步去梵净山再顺路去成都自驾318路线的，但时间紧迫，我弟弟在重庆读书，说要跟我一起去自驾318，我就先去重庆跟他汇合了。

最后那个火锅要适度吃啊，吃两顿辣的我的陈年胃病都犯了，好几天没缓过来，哭晕在厕所，我弟跟个没事人一样，这是我深刻认识到当了多年的社畜的后果就是，经常熬夜加班点外卖，把好好的身体给造坏了。重庆的洪崖洞，解放碑也去了很多次了，这里给个图

成都

抵达成都,在春熙路逛了逛，宽窄巷子之前逛过就没去了，

本来想租自驾神车-坦克300的，价格是普通suv的2倍，结果路上纠结一会的功夫就被抢先租走了（自我反思：以后看准就下手吧，人生有几次这种机会，有啥好犹豫的），租了一辆1.5T的大众SUV，跟我弟一起直奔车行，然后去超市采购路上的食物，大包小包买了一堆，放车后备箱，深夜就起航了

都江堰

教科书上的都江堰，真正去看了，才深深佩服古人治水的智慧，我不是文盲，所以不用一句：卧槽，发表感叹。之前也去过洛阳的黄河小浪底水库，武汉的长江大桥，这些水利工程的智慧。

青城山

这里是青城山下白素贞的故事发源地。爬山是个体力活，当时穿着拖鞋就上山了，下山就傻眼了，不好意思，这里我偷懒了，坐缆车下车，嘿嘿。

泸定桥

打卡泸定桥，走上面摇摇晃晃确实需要一些勇气，特别怕手机掉下去。

海螺沟

一鼓作气，一路直行，抵达海螺沟。来之前，我觉得新能源车咋自驾318，路上看到同样是特斯拉车主，我感觉自己有点狭隘。人啊，果然要多出去看看，不能活在自己的局限认知中。

不过开车还是要小心，路上遇到有车盘山时发生侧翻的。还有山上偶尔会有落石下来，要当心了。

木格措

一路景色壮观，蓝天白云，川西一定要必去。到了康定情歌的原地。打个卡。

不过我路上听的歌一直都是朴树的《平凡之路》，一路循环：

我曾经跨过山和大海 也穿过人山人海

我曾经拥有着的一切 转眼都飘散如烟

我曾经失落失望 失掉所有方向

直到看见平凡 才是唯一的答案
....

不正是正值青春的我受伤了，但又奋力前行寻找答案吗。

四姑娘山

一路直行。。。抵达四姑娘山，四姑娘山有四座雪山组成，远看景色很壮观，雪已经化了很多。

当地信仰

遇到了一群一动不动的牦牛，还有一匹热情好客的长脸马。拿出来一个饼给它，它吃的还很香。本来开心的事现在记录起来突然感觉在暗示自己在公司当牛做马，不说了，emo了。据说那白色塔这是当地的信仰，表示尊重。

雅拉山口

盘山路，1.5T的车开着有点吃力，油门上不去。终于爬上山了，下车拍照时，激动过头了，开始缺氧，头疼，吸氧。。。。。。。。

后面走着走着身体扛不住了，我去当地买了高反的药，吃了没啥用，氧气越吸头越疼，我弟要回去上课，我身体不抗造，遗憾的半途而归了。再次强调一下，好风景要趁年轻，体力好，等老了走不动了，确实再好的风景，都没那心情和体力去欣赏了。

乐山

跟我弟散伙后，我自己开车去了乐山大佛，保佑我顺风顺水吧。还去看了东方佛群，卧佛，药师佛，看了各种佛，记不清楚了。。。

峨眉山

接着我自己又自驾去了峨眉山，两个地方相差不是很远，看到了峨眉山的云海，云雾缭绕，超级刺眼！

下山后当晚接着又踩着点返回成都还车。休息一晚后，又顺路打卡了锦里。感受人世间的烟火和繁华

又吃了一顿火锅后，回上海。这时，胃没有不舒服，看来，这一圈下来，肠胃好很多了。

又回到了我熟悉的大上海。

安徽

经过一段时间的调养后，我觉得的身体状态老好了，爬山那不是小意思，走，爬山去，什么黄山，三清山，庐山，武功山，离沪这么近，爬起来不费劲！我到了安徽省，黄山市，休息一晚准备去爬山。当晚被出租车司机拉到了老街逛逛。

就一个小型的徽派建筑青砖白瓦的特色，跟顾村差不多。逛完后突然下起了大雨，我猝不及防没带伞，
就记得那晚的雨，比情深深雨蒙蒙中依萍找她爸要钱被鞭子抽回去时遇到的那场大雨还大。。。。。。

黄山

不凑巧，上山时遇到了大雾，但来都来了，那就爬山下去吧。到了光明顶也啥都看不见，但幸运的时，下山时，守得云开见月明，气喘吁吁的开心拍照。

江西

黄山结束后，顺路就来到了江西，江西景色比较集中，一定要去上饶啊，那就先去望仙谷看看吧。

上饶-望仙谷

人工打造的经典，现实版的仙侠世界。小雨朦胧，青山傍水，景色秀丽。

上饶-三清山

谁说黄山归来不看山，我觉得三清山值得一去，至少我是不后悔的。每座山都有每座山的特色，爬到这时，腿开始抖了，但我可不是那么轻易就能认输的人啊，继续爬，专挑难爬的道：一线天！！！！！

哈哈，说这个像蟒蛇，像吗？

下山时腿疼的不行，扛不住了，嘴不硬了，不去庐山了，武功山了。。。。

南昌

对了，不明白为啥江西彩礼那么高？

广东

广州

从南昌飞到广州了，看了小蛮腰，在附近喝喝茶，遛遛弯，吃点茶点

深圳

到深圳后租了个车溜达到海边吃海鲜，还去华强北也溜一溜，吃了很多粤菜

香港

从深圳坐高铁到香港也就十几分钟，跟快的。香港巴士，香港茶餐厅，路过金店，想买项链的，但又怕弄丢了就没买，现在金价那么高，有点损失。

新疆

从上海飞新疆要4个多小时，一路太无聊了，下飞机后，心情就好很多

乌鲁木齐

去了大巴扎，吃了羊肉串和切糕，还有新疆大盘鸡

无人区

没信号，没水，荒漠一片。。。

伊犁

到了伊犁市区后，去了小吃街，吃了羊肉

赛里木湖

高原湖泊，非常适合自驾游玩，我这里是跟人拼车去的。看着真舒服，可惜我把单反带来，也背不动，这是人家的

边境-国门，果子沟大桥， 薰衣草

新疆白天长，夜里段，到了晚上9点多，天才慢慢开始变黑。

北京

这次我飞到了老北京，看了天安门，看了老城墙

内蒙古

从北京顺路来了内蒙古呼和浩特，先填饱肚了，去那个什么街买了一堆牛肉干

呼和浩特

青甘环线

说到去青甘，想起有个在学生时期就在玩的狐朋狗友，听说我打算去自驾就想跟我一起去。因为我的车是新能源，自驾充电比较麻烦，他打算提混动车方便些，他说让我等他提车带他一起去自驾，本来约定好了时间，到快出发时，一会又说不打算提车了，又说等他面试换好工作后，最后他自己又各种理由怂了，这种又想出去玩，又想挣钱，又不舍得花钱，这种拧巴的状态，我很无语，当然，这也是现实中大部分人的写实吧，这里我想说，做好权衡利弊和取舍就好，既然决定去追求诗和远方，就不要再去跟钱分文必争了，不可否认，旅行确实需要花钱，我们能做的就是按照自己能承担的最低的成本去看世界。人家说勇敢的人先享受世界，让他纠结犹豫去吧，我就先溜了，毕竟老祖宗给的经验是：欲买桂花同载酒，终不似，少年游。再后来，他说他提车了，问我还去不去，我说我早就已经打卡过了。我问他新工作找好了？他说还没有。。。所以他白拧巴了，车还是要提，想去的地方最终还是要去，挣不了的钱最终还是没到口袋里去。毕竟能随时说走就走的同行者只有自己。

我是从内蒙飞到了青海的西宁。

西宁市

填饱肚子先，然后出发去青海湖，远看蓝色，近看青色，全靠天气

青海湖

茶卡盐湖

天空之境，名不虚传。

丹霞地貌，策马奔腾

策马奔腾很潇洒，归来草原上都是马粪，有点臭。。。
仙气飘飘的牦牛，跟川西的大黑牛不一样

后面的敦煌，莫高窟去不了了，青海也是有3000多海拔的，玩嗨了，又又又高反了，不得已要回去了，哎，当了这么多年生产驴，身体熬废了。回去后多锻炼身体吧。毕竟身体是革命的成本。

武汉

于是，先飞回了武汉玩几天。回家转转，熟悉的感觉。喜欢武汉的大江大湖和历史文化。黄鹤一去不复返，白云千载空悠悠。
然后又从武汉飞到上海狗着。

上海市

这个城市充满了魅力。只要你有钱，就可以纸醉金迷，去和平饭店享受，去挥霍。没钱，只能继续搬砖。

回去后改善饮食，一边努力干活学习，一边下定决心锻炼，都有马甲线了，五公里so easy ，哈哈哈哈。每次回到上海这个繁华的国际大都市，我都深深感受到，这座城市虽然压力大，但终究是自由的，没人关心和打扰你的私人生活，你可以为自己而活，安排自己的一生，不必循规蹈矩，不必顾及世俗的眼光，这个城市包容能力很强，不妨大胆一些，追求自己的人生。去不同的城市体验不一样的生活和文化。

在买随心飞之前我也去过很多城市，比如：湖北的荆州，湖南的岳阳，张家界，广东的东莞，广西的桂林和北海，海南的三亚，云南的昆明大理丽江，江浙沪包邮一带的杭州，南京，无锡，湖州，台州，宁波，福建的厦门，河南的洛阳，开封，郑州，信阳，山东青岛，陕西西安，安徽合肥等城市。时间有限，码字不易，很抱歉这里我就不全部列出了。尤其在学生时代，那是真的快乐，没有一丝丝杂念，单纯的快乐。后面打算环游世界了，已经去了东南亚的一些国家，这里我想说我本来就是为了WLB努力的，工作生活两不误，我的旅途未完待续～

回顾这么多年，走过的国内大大小小的城市，也没具体统计过，开始逐渐让自己的眼界开阔起来，不让自己的眼光那么狭隘了，看待任何事物更具包容性吧，以前不理解的东西，现在慢慢理解了。也许人生就是这样，思想和观念一直变化。还是那句话，勇敢的人先享受人生吧，不要辜负努力写代码的自己。

转载好文：雷锋网 本文作者：何思思

2023年4月28日，即4月28日凌晨，玉伯发朋圈称将要离开蚂蚁，今天也是玉伯在蚂蚁的最后一天。

他写道：“再见，山峰下的园区。一个人选择远行，并不一定是马云说的钱给少了或者心委屈了，也可以是为了远方有西湖般的美景。”下面的配图是园区风景，还有眺望远方的景色。

不愿做技术大佬，要做为产品服务的技术

“前端大牛、技术大佬”是业界给玉伯贴的标签，2008年加入淘宝后，玉伯先后做出了前端领域很火的框架 SeaJS、KISSY，之后带领团队通过开源做了很多技术产品。

但玉伯始终认为，技术只是工具，最终还是要为产品服务。所以当时在淘宝内部，玉伯一直是“折腾”的状态，加入淘宝那年，玉伯就参加了内部的赛马机制，跟团队做了几个月的创新产品，最后以失败告终，又回到了Java 团队做技术。

但这并有改变他要做创新产品的初心，于是2010 年到2011年，他一边做技术研发，一边继续摸索创新产品，但一直没做出能拿的出手的产品。直到2016年，在蚂蚁体验技术部的创新产品孵化机制策马扬鞭项目中，玉伯团队主导的语雀问世，并于2018年正式对公网提供服务。

也有内部人士称：玉伯当时和老板提了条件说，光做前端没意思，你要想留住我，就得给我一款产品做。所以当时玉伯自己要了一个团队，专门做一个闭环产品。

其实，从语雀诞生到现在经历了两次生死局：第一次是2018年，腾讯文档、钉钉文档、飞书文档相继亮相，文档产品迎来爆发期，当时阿里也想抓住这个风口，语雀最终把三分之二的人输送给了钉钉，作为钉钉文档的初始团队。在团队仅剩七八个人的时候，玉伯再次招人将团队扩充到二十人左右。

第二次是2020年，彼时，钉钉文档做了很久但并没达到预期效果，而语雀正值上升期，阿里云为了尽快把文档做起来，想把语雀、钉钉文档、阿里云笔记等内部各种文档团队聚集起来，成立一个独立的阿里文档事业部，由玉伯牵头，但却被无招反对，这也间接帮助了玉伯。

直到2021年，蚂蚁成立了智能协同事业部，其中语雀作为重点产品，以独立BU运作。

创业中的理想派，为了做好一件事而做

从2016年到现在，为了做好语雀，玉伯做了大量的工作。

玉伯曾回忆道，做语雀最大的一个感触是，啥都得做。最开始是半个PD，很快变成了客服，同时兼做运营，还需要去承担BD的工作，因为没有BD，只能逼着自己去做，一切为了产品往前跑。

也有用户在即刻分享道，自己曾经在语雀的付费用户群中提了一个文档的排序问题，当时玉伯就在群里，很快的响应了这个需求并做了优化。

此外，玉伯也背负了巨大的营收压力，尤其是近两年在阿里集团整体缩紧的状态下。雷峰网通过其他渠道了解到，集团也给语雀定了目标——“盈亏平衡”。

迫于压力，近两年语雀也调整了收费策略，2019年语雀开始尝试简单的商业化模式，即初级的团队语雀空间和语雀个人的收费版本；紧接着又重新设计了个人版价格策略，分为99元会员、199元超级会员、299元至尊会员三个档次，团队和空间版的收费则更高。

这对一个小团队来说并不容易，首先，较钉钉、飞书、腾讯文档而言，语雀强调的是知识管理的逻辑，其次，语雀服务的对象偏小众聚焦在侧重知识管理的用户，且这些目标对象比较分散，很难第一时间发掘到，这就意味着需要花很长时间去培养，没办法快速完成转化；再就是，虽然语雀团队不大，只有五六十人左右，但这部分人大都是互联网人才，成本也是一笔不小的支出。

雷峰网在之前拜访玉伯时听闻，目前语雀主要服务蚂蚁和阿里内部，在阿里内的日活已经达到了11万左右，商业化方面还比较单一，主要是通过发布会的方式宣传。由此可见，语雀的商业化路径还没完全打开。

无论选择出去创业还是集团内部创业，背负营收压力都是不可避免的。但抛开这个不谈，仅玉伯的个人角度出发，他曾谈过自己做语雀的初心，就是想把自己内心想做的事情做完，且这件事还能帮助到别人，就做了。

正是这种简单纯粹的心态，让玉伯在做语雀时只专注事情的本身以及这件事情创造的价值，而并非拼命地追求变现。

雷峰网(公众号：雷峰网)曾发表文章《留给飞书的时间》，他如此评论：

“现实主义者关注的是钱，理想主义者关注的是时间，当代这个社会，钱很重要。但更重要的，对个体来说，是如何提高时间的质量，对人类来说，不仅关注时间的质量，还关注整个人类时间的长短，是否可延续下去。赚钱是为了花钱，花钱是为了提升时间的品质甚至长度。围绕钱的现实主义者，最终会为围绕时间的理想主义者服务。”

从玉伯最新的朋友圈内容，不难看出，他的离开或许和钱权没有太大的关系，而是为了追求心目中的诗和远方。他也曾经说过自己有三个梦：“技术梦、产品梦、自由梦。”离开蚂蚁，或许是为了去实现他的“自由梦。”

在Activity间传递的数据一般比较简单，但是有时候实际开发中也会传一些比较复杂的数据，尤其是面试问道当遇到需要在Activity间传递大量的数据怎么办？

Intent 传递数据的大小是有限制的，它大概能传的数据是1M-8K，原因是Binder锁映射的内存大小就是1M-8K.一般activity间传递数据会要使用到binder，因此这个就成为了数据传递的大小的限制。那么当activity间要传递大数据采用什么方式呢？其实方式很多，我们就举几个例子给大家说明一下，但是无非就是使用数据持久化，或者内存共享方案。一般大数据的存储不适宜使用SP， MMKV，DataStore。

Activity之间传递大量数据主要有如下几种方式实现：

• LruCache


• 持久化（sqlite、file等）


• 匿名共享内存

使用LruCache

LruCache是一种缓存策略，可以帮助我们管理缓存，想具体了解的同学可以去Glide章节中具体先了解下。在当前的问题下，我们可以利用LruCache存储我们数据作为一个中转，好比我们需要Activity A向Activity B传递大量数据，我们可以Activity A先向LruCache先写入数据，之后Activity B从LruCache读取。

首先我们定义好写入读出规则：

public interface IOHandler {

    //保存数据

    void put(String key, String value);

    void put(String key, int value);

    void put(String key, double value);

    void put(String key, float value);

    void put(String key, boolean value);

    void put(String key, Object value);



    //读取数据

    String getString(String key);

    double getDouble(String key);

    boolean getBoolean(String key);

    float getFloat(String key);

    int getInt(String key);

    Object getObject(String key);

}

我们可以根据规则也就是接口，写出具体的实现类。实现类中我们保存数据使用到LruCache，这里面我们一定要设置一个大小，因为内存中数据的最大值是确定，我们保存数据的大小最好不要超过最大值的1/8.

LruCache mCache = new LruCache<>( 10 * 1024*1024);

写入数据我们使用比较简单：

@Override

public void put(String key, String value) {

    mCache.put(key, value);

}

好比上面写入String类型的数据，只需要接收到的数据全部put到mCache中去。

读取数据也是比较简单方便：

@Override

public String getString(String key) {

    return String.valueOf(mCache.get(key));

}

持久化数据

那就是sqlite、file等方式。将需要传递的数据写在临时文件或者数据库中，再跳转到另外一个组件的时候再去读取这些数据信息，这种处理方式会由于读写文件较为耗时导致程序运行效率较低。这种方式特点如下：

优势：

（1）应用中全部地方均可以访问

（2）即便应用被强杀也不是问题了

缺点：

（1）操做麻烦

（2）效率低下

匿名共享内存

在跨进程传递大数据的时候，我们一般会采用binder传递数据，但是Binder只能传递1M一下的数据，所以我们需要采用其他方式完成数据的传递，这个方式就是匿名共享内存。

「Anonymous Shared Memory 匿名共享内存」是 Android 特有的内存共享机制，它可以将指定的物理内存分别映射到各个进程自己的虚拟地址空间中，从而便捷的实现进程间内存共享。

Android 上层提供了一些内存共享工具类，就是基于 Ashmem 来实现的，比如 MemoryFile、 SharedMemory。

以前听过过一个有趣的说法：不要编写没有明显bug的代码，要去编写明显没有bug的代码。这里提到的两个概念：“没有明显bug的代码”和“明显没有bug的代码”。同样的文字，只是调换了下顺序，表达的就是完全不同的概念了。前者“没有明显bug的代码”大概是最常见的代码了，特征就是：

平时工作中到处缝缝补补的代码大概就是这种代码吧。背后的原因一般比较复杂，有时还不可追溯，项目工期紧，人员交接等等都有可能。因此，与其思考“如何避免没有明显bug的代码”，还不如思考“如何写出明显没有bug的代码”。本文就何为“明显没有bug的代码”总结一些个人的思的胡思乱想，阐述这类代码的几个特征。

特征1：代码简短

“明显没有xx”意味着一眼能看出来，而“一眼”这个条件就有很大的限制。如果给我一个函数，包含1000多行代码，我鼠标滚轮要滚好久，才能过完一遍代码，那么这种代码一定不是“明显没有bug的代码”。那么，反过来说，“明显没有bug的代码”一定是短小的代码。比如，Java中的Objects.equals方法：

public static boolean equals(Object a, Object b) {

    return (a == b) || (a != null && a.equals(b));

}

这一段代码简短到，代码跟功能定义的文字篇幅差不多，连写文档注释的必要都没有了。还有一个更极端的例子是Java的Objects.isNull方法：

public static boolean isNull(Object obj) {

    return obj == null;

}

简直就是一段“废话”。

特征2：功能完整且连贯

“一眼能看出”还意味着功能不能太分散，如果一个功能，分散在十多个函数或文件中，那么看这段功能就得在很多代码片段中跳来跳去，这个就需要开发者来阅读代码时充当一个“人肉解释器”的角色，在大脑中把各个代码片段组合起来才能明白整个流程和细节，这无疑降低阅读代码的效率，bug也容易隐藏在各个代码片段的“缝隙”中。举个常见的例子：在图形界面应用中，用户登录后，弹出登录成功的提示，然后关闭登录页面。一种普通的实现是：

//1. 在登录按钮触发登录操作

loginButton.setOnClickListener(v -> controller.login(username, poassword))



//2. 在登录成功的回调中展示弹窗

public void onLoginSuccess(User user){

    LoginSuccessDialog.show("login success")

}



//3. 在失败的回调中展示错误信息

public void onLoginFailed(String errorMsg){

    MessageDialog.showMessage(errorMsg);

}



//4. 在LoginSuccessDialog确认后关闭页面

public void onLoginDialogConfirmed(){

    loginPage.close();

}

看上去好像解耦很不错，但功能都变得七零八落。要拼凑出完整的功能大概得仔细阅读整段代码，更别提“一眼看出”了。那么一眼能看出的代码大概长啥样呢？我想，大概是这样：

loginButton.setOnClickListener(v -> {

    controller.login(username, poassword)

            .onSuccess(user ->

                    LoginSuccessDialog.总而言之，解耦需谨慎，不要因过度解耦而牺牲了内聚性和连贯性。show("login success")

                            .onConfirmed(() -> loginPage.close()))

            .onFailed(errorMsg ->

                    MessageDialog.showMessage(errorMsg));

});

这是对该视图流程的一个连贯的描述，而且篇幅更短。至于获取到用户数据存储到本地数据库、通知其他页面更新等操作，跟当前视图没有关系，也就不需要放在这段代码里。总而言之，解耦需谨慎，不要因过度解耦而牺牲了内聚性和连贯性。

特征3：良好的表达

代码的篇幅得到控制后，要让人一眼看懂，还需要容易理解才行。设计心理学提出“设计传达所有必要的信息，创造一个良好的系统概念模型，引导用户理解系统状态，带来掌控感”。程序设计也是如此，代码是程序功能的文本表达，需要传达对应信息来让人产生该功能正确的概念模型。

以一个常见的上传图片的弹窗为例，思考一个菜单弹窗，包含取消和两个功能按钮：从相册选择和拍照上传，例如下图这样。

那么对应的代码可以表达为：

MenuDialog.create()

        .withAction("拍照上传", dialog -> {

            takePhoto();

        })

        .withAction("本地上传", dialog -> {

            chooseFromGallery();

        })

        .onCancel(() -> {

            //do something

        })

        .show();

或者

MenuDialog.create()

        .withAction("拍照上传", controller::takePhoto)

        .withAction("本地上传", controller::chooseFromGallery)

        .onCancel(() -> {

            //do something

        })

        .show();

没有多余的代码，该有的信息都表达到位，而且和实际功能有良好的对应关系。

4. 特征4：可验证正确性

代码可以让人一眼看懂之后，那么判断其有没有bug，还有一个重要前提：这个代码是有正确性可言的，可以被验证。

例如，来看下面这段随意的代码：

int type;

boolean isClosed;



void doSomething(String text) {

    if (type == 0) {

        if (isClosed) {

            println(text);

        } else {

            error("something wrong");

        }

    } else if (type == 1) {

        //do something

    }

}

这段程序简短、易读，但是doSomething函数的行为依赖两个外部变量，而这两个外部变量又容易被其他地方随意改动。比如，type的定义域为1、2、3，但如果type新增类型4的时候或者被错误地赋值为-1的时候，这个doSomething函数的行为还是正确的吗？doSomething函数的正确性依赖于type变量的正确性，那么又依赖于读写type变量的程序的正确性，这样的程序是难以验证的。而且，对上下文依赖越多的程序，越难以产生明确的定义，因为这个定义也依赖上下文的定义。定义不明确，更难以验证内容的正确性。

相比之下，Objects.equals和Objects.isNull方法有着明确的定义，而且不受上下文影响，可以一眼就看出对错。而下面这段代码：

MenuDialog.create()

        .withAction("拍照上传", controller::takePhoto)

        .withAction("本地上传", controller::chooseFromGallery)

        .onCancel(() -> {

            //do something

        })

        .show();

表达明确，可以快速判断出程序行为是否正确、符合期望。即便MenuDialog出现异常，或者takePhoto和chooseFromGallery出了什么问题，也不需要来修改这段程序。

不过，程序验证是一个有点高深的科研方向，要严格验证一个程序的正确性是很困难的一件事，不过我们仍然可以试着去编写一些“看起来”正确的程序。（利用函数式编程思想写出来的代码通常容易验证一些）

正好最近业内接连发生了几起影响比较大的故障，那我们就专门做一期「故障专辑」吧。

故障

故障有好几种叫法，比较正式的

• 故障 - Outage


• 事故 - Incident

不怎么严重的，时间很短的

• 抖了一下 - Jitter（多用于网络）


• Hiccup (中文翻译是打了个嗝，不过中文里貌似没有这个讲法）

通俗点的说法

• 挂了/崩了- Down
  

500

当在请求某个网络资源时，服务器内部发生错误时，返回的错误编号。扩展为系统发生内部故障。

变更

虽然突然的流量暴涨，或者光缆被挖断，数据中心着火，被雷劈都有可能，但绝大多数时候，故障都是变更导致的。

变更分为三大类：

• 代码变更 - Code Change


• 配置变更 - Config Change


• 数据库变更 - Database Change

左移 (shift-left)

降低变更风险的一个方法，就是做变更前检查，问题越早发现越好。因为变更的流水线是从左往右画的，起点在左边。所以左移就是把检查尽量靠近起点。

金丝雀 (Canary)

以前矿工下井，会带一只金丝雀，如果井下空气出现状况，更敏感的金丝雀会先有异常。这个概念也带到了软件研发里。会循序渐进地做变更。另外一种叫法是灰度 (Grayscale)。

单元化/区域化 (Regionalization)

在互联网公司逐渐普及的架构，主要由 AWS 发扬光大，把服务进行隔离。

爆炸半径 (Blast Radius)

金丝雀和单元化都是为了降低爆炸半径，减少故障的影响面。

值班 (On-call)

也叫 Carry the pager。以前带着的传呼机叫做 Pager。现在传呼机被手机/软件取代了，但 Pager 这个名字沿用了下来。

复盘 (Postmortem)

原义是尸检报告。在软件研发领域，指详细的故障分析报告。

惊群 (Thundering Herd)

打雷后，动物一下子被惊醒了，到处乱窜，造成混乱。在故障恢复阶段要小心的问题，很容易刚拉起一个服务，立马又被积压的请求打挂。

结语

船停在港口是最安全的，但那不是造船的目的。软件需要持续的变更迭代，变更就有风险。但研发团队可以通过引入工具，来降低风险，针对一开始变更的三种类型，市面上也有成熟的开源方案：
代码变更 - 老牌的有 Jenkins，新兴的有 Drone CI 和 Zadig

大家好，我是二哥呀。

对于 Java 初学者来说，多线程的很多概念听起来就很难理解。比方说：

• 进程，是对运行时程序的封装，是系统进行资源调度和分配的基本单位，实现了操作系统的并发。


• 线程，是进程的子任务，是 CPU 调度和分派的基本单位，实现了进程内部的并发。

很抽象，对不对？打个比喻，你在打一把王者（其实我不会玩哈 doge）：

• 进程可以比作是你开的这一把游戏


• 线程可以比作是你所选的英雄或者是游戏中的水晶野怪等之类的。

带着这个比喻来理解进程和线程的一些关系，一个进程可以有多个线程就叫多线程。是不是感觉非常好理解了？

进程和线程

❤1、线程在进程下进行

（单独的英雄角色、野怪、小兵肯定不能运行）

❤2、进程之间不会相互影响，主线程结束将会导致整个进程结束

（两把游戏之间不会有联系和影响。你的水晶被推掉，你这把游戏就结束了）

❤3、不同的进程数据很难共享

（两把游戏之间很难有联系，有联系的情况比如上把的敌人这把又匹配到了）

❤4、同进程下的不同线程之间数据很容易共享

（你开的那一把游戏，你可以看到每个玩家的状态——生死，也可以看到每个玩家的出装等等）

❤5、进程使用内存地址可以限定使用量

（开的房间模式，决定了你可以设置有多少人进，当房间满了后，其他人就进不去了，除非有人退出房间，其他人才能进）

创建线程的三种方式

搞清楚上面这些概念之后，我们来看一下多线程创建的三种方式：

继承 Thread 类

♠①：创建一个类继承 Thread 类，并重写 run 方法。

public class MyThread extends Thread {

    @Override

    public void run() {

        for (int i = 0; i < 100; i++) {

            System.out.println(getName() + ":打了" + i + "个小兵");

        }

    }

}

我们来写个测试方法验证下：

//创建MyThread对象

MyThread t1=new  MyThread();

MyThread t2=new  MyThread();

MyThread t3=new  MyThread();

//设置线程的名字

t1.setName("鲁班");

t2.setName("刘备");

t3.setName("亚瑟");

//启动线程

t1.start();

t2.start();

t3.start();

来看一下执行后的结果：

实现 Runnable 接口

♠②：创建一个类实现 Runnable 接口，并重写 run 方法。

public class MyRunnable implements Runnable {

    @Override

    public void run() {

        for (int i = 0; i < 10; i++) {

            try {//sleep会发生异常要显示处理

                Thread.sleep(20);//暂停20毫秒

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(Thread.currentThread().getName() + "打了:" + i + "个小兵");

        }

    }

}

我们来写个测试方法验证下：

//创建MyRunnable类

MyRunnable mr = new MyRunnable();

//创建Thread类的有参构造,并设置线程名

Thread t1 = new Thread(mr, "张飞");

Thread t2 = new Thread(mr, "貂蝉");

Thread t3 = new Thread(mr, "吕布");

//启动线程

t1.start();

t2.start();

t3.start();

来看一下执行后的结果：

实现 Callable 接口

♠③：实现 Callable 接口，重写 call 方法，这种方式可以通过 FutureTask 获取任务执行的返回值。

public class CallerTask implements Callable<String> {

    public String call() throws Exception {

        return "Hello,i am running!";

    }



    public static void main(String[] args) {

        //创建异步任务

        FutureTask<String> task=new FutureTask<String>(new CallerTask());

        //启动线程

        new Thread(task).start();

        try {

            //等待执行完成，并获取返回结果

            String result=task.get();

            System.out.println(result);

        } catch (InterruptedException e) {

            e.printStackTrace();

        } catch (ExecutionException e) {

            e.printStackTrace();

        }

    }

}

关于线程的一些疑问

❤1、为什么要重写 run 方法？

这是因为默认的run()方法不会做任何事情。

为了让线程执行一些实际的任务，我们需要提供自己的run()方法实现，这就需要重写run()方法。

public class MyThread extends Thread {

  public void run() {

    System.out.println("MyThread running");

  }

}

在这个例子中，我们重写了run()方法，使其打印出一条消息。当我们创建并启动这个线程的实例时，它就会打印出这条消息。

❤2、run 方法和 start 方法有什么区别？

• run()：封装线程执行的代码，直接调用相当于调用普通方法。


• start()：启动线程，然后由 JVM 调用此线程的 run() 方法。

❤3、通过继承 Thread 的方法和实现 Runnable 接口的方式创建多线程，哪个好？

实现 Runable 接口好，原因有两个：

• ♠①、避免了 Java 单继承的局限性，Java 不支持多重继承，因此如果我们的类已经继承了另一个类，就不能再继承 Thread 类了。


• ♠②、适合多个相同的程序代码去处理同一资源的情况，把线程、代码和数据有效的分离，更符合面向对象的设计思想。Callable 接口与 Runnable 非常相似，但可以返回一个结果。

控制线程的其他方法

针对线程控制，大家还会遇到 3 个常见的方法，我们来一一介绍下。

1）sleep()

使当前正在执行的线程暂停指定的毫秒数，也就是进入休眠的状态。

需要注意的是，sleep 的时候要对异常进行处理。

try {//sleep会发生异常要显示处理

    Thread.sleep(20);//暂停20毫秒

} catch (InterruptedException e) {

    e.printStackTrace();

}

2）join()

等待这个线程执行完才会轮到后续线程得到 cpu 的执行权，使用这个也要捕获异常。

//创建MyRunnable类

MyRunnable mr = new MyRunnable();

//创建Thread类的有参构造,并设置线程名

Thread t1 = new Thread(mr, "张飞");

Thread t2 = new Thread(mr, "貂蝉");

Thread t3 = new Thread(mr, "吕布");

//启动线程

t1.start();

try {

    t1.join(); //等待t1执行完才会轮到t2，t3抢

} catch (InterruptedException e) {

    e.printStackTrace();

}

t2.start();

t3.start();

来看一下执行后的结果：

3）setDaemon()

将此线程标记为守护线程，准确来说，就是服务其他的线程，像 Java 中的垃圾回收线程，就是典型的守护线程。

//创建MyRunnable类

MyRunnable mr = new MyRunnable();

//创建Thread类的有参构造,并设置线程名

Thread t1 = new Thread(mr, "张飞");

Thread t2 = new Thread(mr, "貂蝉");

Thread t3 = new Thread(mr, "吕布");



t1.setDaemon(true);

t2.setDaemon(true);



//启动线程

t1.start();

t2.start();

t3.start();

如果其他线程都执行完毕，main 方法（主线程）也执行完毕，JVM 就会退出，也就是停止运行。如果 JVM 都停止运行了，守护线程自然也就停止了。

小结

本文主要介绍了 Java 多线程的创建方式，以及线程的一些常用方法。最后再来看一下线程的生命周期吧，一图胜千言。

好了，如果你想学好 Java，GitHub 上标星 10000+ 的《二哥的 Java 进阶之路》不容错过，据说每一个优秀的 Java 程序员都喜欢她，风趣幽默、通俗易懂。内容包括 Java 基础、Java 并发编程、Java 虚拟机、Java 企业级开发（Git、Nginx、Maven、Intellij IDEA、Spring、Spring Boot、Redis、MySql 等等）、Java 面试等核心知识点。学 Java，就认准二哥的 Java 进阶之路😄。

Github 仓库：github.com/itwanger/to…

码云仓库（国内访问更快）：gitee.com/itwanger/to…

star 了这个仓库就等于你拥有了成为了一名优秀 Java 工程师的潜力。

把二哥的座右铭送给你：没有什么使我停留——除了目的，纵然岸旁有玫瑰、有绿荫、有宁静的港湾，我是不系之舟。

前言

假如有一天我们要按代码量来算工资，那怎样才能写出一手漂亮的代码，同时兼顾代码行数和实际意义呢？

要在增加代码量的同时提高代码质量和可维护性，能否做到呢？

答案当然是可以，这可难不倒我们这种摸鱼高手。

耐心看完，你一定有所收获。

正文

1. 实现更多的接口：

给每一个方法都实现各种“无关痛痒”的接口，比如Serializable、Cloneable等，真正做到不影响使用的同时增加了相当数量的代码。

为了这些代码量，其中带来的性能损耗当然是可以忽略的。

public class ExampleClass implements Serializable, Comparable<ExampleClass>, Cloneable, AutoCloseable {



    @Override

    public int compareTo(ExampleClass other) {

        // 比较逻辑

        return 0;

    }



    // 实现 Serializable 接口的方法

    private void writeObject(ObjectOutputStream out) throws IOException {

        // 序列化逻辑

    }



    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {

        // 反序列化逻辑

    }



    // 实现 Cloneable 接口的方法

    @Override

    public ExampleClass clone() throws CloneNotSupportedException {

        // 复制对象逻辑

        return (ExampleClass) super.clone();

    }



    // 实现 AutoCloseable 接口的方法

    @Override

    public void close() throws Exception {

        // 关闭资源逻辑

    }



}

除了示例中的Serializable、 Comparable、 Cloneable、 AutoCloseable，还有Iterable

2. 重写 equals 和 hashcode 方法

重写 equals 和 hashCode 方法绝对是上上策，不仅增加了代码量，还为了让对象在相等性判断和散列存储时能更完美的工作，确保代码在处理对象相等性时更准确、更符合业务逻辑。

public class ExampleClass {

    private String name;

    private int age;



    // 重写 equals 方法

    @Override

    public boolean equals(Object obj) {

        if (this == obj) {

            return true;

        }



        if (obj == null || getClass() != obj.getClass()) {

            return false;

        }



        ExampleClass other = (ExampleClass) obj;

        return this.age == other.age && Objects.equals(this.name, other.name);

    }

    

    // 重写 hashCode 方法

    @Override

    public int hashCode() {

        return Objects.hash(name, age);

    }

}

3. 增加配置项和参数：

不要管能不能用上，梭哈就完了，问就是为了健壮性和拓展性。

public class AppConfig {

    private int maxConnections;

    private String serverUrl;

    private boolean enableFeatureX;



    // 新增配置项

    private String emailTemplate;

    private int maxRetries;

    private boolean enableFeatureY;



    // 写上构造函数和getter/setter

}

4. 增加监听回调：

给业务代码增加监听回调，比如执行前、执行中、执行后等各种Event，这里举个完整的例子。

比如创建个 EventListener ，负责监听特定类型的事件，事件源则是产生事件的对象。通过EventListener 在代码中增加执行前、执行中和执行后的事件。

首先，我们定义一个简单的事件类 Event：

public class Event {

    private String name;



    public Event(String name) {

        this.name = name;

    }



    public String getName() {

        return name;

    }

}

然后，我们定义一个监听器接口 EventListener：

public interface EventListener {

    void onEventStart(Event event);



    void onEventInProgress(Event event);



    void onEventEnd(Event event);

}

接下来，我们定义一个事件源类 EventSource，在执行某个业务方法时，触发事件通知：

public class EventSource {

    private List<EventListener> listeners = new ArrayList<>();



    public void addEventListener(EventListener listener) {

        listeners.add(listener);

    }



    public void removeEventListener(EventListener listener) {

        listeners.remove(listener);

    }



    public void businessMethod() {

        Event event = new Event("BusinessEvent");



        // 通知监听器：执行前事件

        for (EventListener listener : listeners) {

            listener.onEventStart(event);

        }



        // 模拟执行业务逻辑

        System.out.println("Executing business method...");



        // 通知监听器：执行中事件

        for (EventListener listener : listeners) {

            listener.onEventInProgress(event);

        }



        // 模拟执行业务逻辑

        System.out.println("Continuing business method...");



        // 通知监听器：执行后事件

        for (EventListener listener : listeners) {

            listener.onEventEnd(event);

        }

    }

}

现在，我们可以实现具体的监听器类，比如 BusinessEventListener，并在其中定义事件处理逻辑：

public class BusinessEventListener implements EventListener {

    @Override

    public void onEventStart(Event event) {

        System.out.println("Event Start: " + event.getName());

    }



    @Override

    public void onEventInProgress(Event event) {

        System.out.println("Event In Progress: " + event.getName());

    }



    @Override

    public void onEventEnd(Event event) {

        System.out.println("Event End: " + event.getName());

    }

}

最后，我们写个main函数来演示监听事件：

public class Main {

    public static void main(String[] args) {

        EventSource eventSource = new EventSource();

        eventSource.addEventListener(new BusinessEventListener());



        // 执行业务代码，并触发事件通知

        eventSource.businessMethod();



        // 移除监听器

        eventSource.removeEventListener(businessEventListener);

    }

}

如此这般那般，代码量猛增，还顺带实现了业务代码的流程监听。当然这只是最简陋的实现，真实环境肯定要比这个复杂的多。

5. 构建通用工具类：

同样的，甭管用不用的上，定义更多的方法，都是为了健壮性。

比如下面这个StringUtils，可以从ApacheCommons、SpringBoot的StringUtil或HuTool的StrUtil中拷贝更多的代码过来，美其名曰内部工具类。

public class StringUtils {

    public static boolean isEmpty(String str) {

        return str == null || str.trim().isEmpty();

    }



    public static boolean isBlank(String str) {

        return str == null || str.trim().isEmpty();

    }



    // 新增方法：将字符串反转

    public static String reverse(String str) {

        if (str == null) {

            return null;

        }

        return new StringBuilder(str).reverse().toString();

    }



    // 新增方法：判断字符串是否为整数

    public static boolean isInteger(String str) {

        try {

            Integer.parseInt(str);

            return true;

        } catch (NumberFormatException e) {

            return false;

        }

    }

}

6. 添加新的异常类型：

添加更多异常类型，对不同的业务抛出不同的异常，每种异常都要单独去处理

public class CustomException extends RuntimeException {

    // 构造函数

    public CustomException(String message) {

        super(message);

    }



    // 新增异常类型

    public static class NotFoundException extends CustomException {

        public NotFoundException(String message) {

            super(message);

        }

    }



    public static class ValidationException extends CustomException {

        public ValidationException(String message) {

            super(message);

        }

    }

}

// 示例：添加不同类型的异常处理

public class ExceptionHandling {

    public void process(int value) {

        try {

            if (value < 0) {

                throw new IllegalArgumentException("Value cannot be negative");

            } else if (value == 0) {

                throw new ArithmeticException("Value cannot be zero");

            } else {

                // 正常处理逻辑

            }

        } catch (IllegalArgumentException e) {

            // 异常处理逻辑

        } catch (ArithmeticException e) {

            // 异常处理逻辑

        }

    }

}

7. 实现更多设计模式：

在项目中运用更多设计模式，也不失为一种合理的方式，比如单例模式、工厂模式、策略模式、适配器模式等各种常用的设计模式。

比如下面这个单例，大大节省了内存空间，虽然它存在线程不安全等问题。

public class SingletonPattern {

    // 单例模式

    private static SingletonPattern instance;



    private SingletonPattern() {

        // 私有构造函数

    }



    public static SingletonPattern getInstance() {

        if (instance == null) {

            instance = new SingletonPattern();

        }

        return instance;

    }



}

还有下面这个策略模式，能避免过多的if-else条件判断，降低代码的耦合性，代码的扩展和维护也变得更加容易。

// 策略接口

interface Strategy {

    void doOperation(int num1, int num2);

}



// 具体策略实现类

class AdditionStrategy implements Strategy {

    @Override

    public void doOperation(int num1, int num2) {

        int result = num1 + num2;

        System.out.println("Addition result: " + result);

    }

}



class SubtractionStrategy implements Strategy {

    @Override

    public void doOperation(int num1, int num2) {

        int result = num1 - num2;

        System.out.println("Subtraction result: " + result);

    }

}



// 上下文类

class Context {

    private Strategy strategy;



    public Context(Strategy strategy) {

        this.strategy = strategy;

    }



    public void executeStrategy(int num1, int num2) {

        strategy.doOperation(num1, num2);

    }

}



// 测试类

public class StrategyPattern {

    public static void main(String[] args) {

        int num1 = 10;

        int num2 = 5;



        // 使用加法策略

        Context context = new Context(new AdditionStrategy());

        context.executeStrategy(num1, num2);



        // 使用减法策略

        context = new Context(new SubtractionStrategy());

        context.executeStrategy(num1, num2);

    }

}

对比下面这段条件判断，高下立判。

public class Calculator {

    public static void main(String[] args) {

        int num1 = 10;

        int num2 = 5;

        String operation = "addition"; // 可以根据业务需求动态设置运算方式



        if (operation.equals("addition")) {

            int result = num1 + num2;

            System.out.println("Addition result: " + result);

        } else if (operation.equals("subtraction")) {

            int result = num1 - num2;

            System.out.println("Subtraction result: " + result);

        } else if (operation.equals("multiplication")) {

            int result = num1 * num2;

            System.out.println("Multiplication result: " + result);

        } else if (operation.equals("division")) {

            int result = num1 / num2;

            System.out.println("Division result: " + result);

        } else {

            System.out.println("Invalid operation");

        }

    }

}

8. 扩展注释和文档：

如果要增加代码量，写更多更全面的注释也不失为一种方式。

/**

 * 这是一个示例类，用于展示增加代码数量的技巧和示例。

 * 该类包含一个示例变量 value 和示例构造函数 ExampleClass(int value)。

 * 通过示例方法 getValue() 和 setValue(int newValue)，可以获取和设置 value 的值。

 * 这些方法用于展示如何增加代码数量，但实际上并未实现实际的业务逻辑。

 */

public class ExampleClass {



    // 示例变量

    private int value;



    /**

     * 构造函数

     */

    public ExampleClass(int value) {

        this.value = value;

    }



    /**

     * 获取示例变量 value 的值。

     * @return 示范变量 value 的值

     */

    public int getValue() {

        return value;

    }



    /**

     * 设置示例变量 value 的值。

     * @param newValue 新的值，用于设置 value 的值。

     */

    public void setValue(int newValue) {

        this.value = newValue;

    }

}

结语

哪怕是以代码量算工资，咱也得写出高质量的代码，合理合法合情的赚票子。

前言

在掘金多年，我一直是一个读者，从事前端快8年了，每天都在看一些视频和资料以及别人的日记，零零碎碎我也做过一些笔记，但是都不成体系。这些笔记至今留存在各种应用上，写了就再也没打开过，还是没有养成习惯，我希望能坚持下去，为自己的人生添加一点历史，等以后老了，我还能证明我的青春有过一些记录，偶尔回味也会是一件比较幸福的事情。

近些年，感觉社会戾气挺重的，特别是疫情的时候，抖音里面的那些评论很让人糟心，现在年轻人也逐渐选择躺平，也是对社会的卷系妥协，随着经济的下滑，一般学校的研究生可能都很难找到一个比较ok的工作，更别提本科或者大专，作为学历真的拿不出手的我，更加焦虑。

从业前端快8年了，做过很多类型的项目，小到一般的H5展示网页，大到区块链应用、智能能源项目；其实回过头来看，没有什么大的成就感，我的从业经验只获得过一次奖杯，就是吃苦耐劳奖一个镀金的大手指，那还是我4年前在一家外包公司连续工作48小时做一个小程序上线后，老板看我确实辛苦，于是发了一个这个奖杯给我，后面被我娃摔坏了，就啥也没有了。

2023

2023年其实回头来看，收获并不是很大，归纳下来也没有几条：

2024 展望

2024年还有几天就到了，我希望每一年都能有点收获吧，立几个flag：

行业展望

目前行业有些自媒体在唱衰，说前端已死，但是我觉得没这么悲观，国家多次强调往智能方向发展，各行业的智能得依托计算机才能智能，像什么智慧制造，智慧能源，智慧农村等等都需要计算机技术来运算和展示。前端只是比以前的要求会高一些了，在5,6年前对前端技术要求没有那么高，大家0基础都可以参与，但如今可能不行了，我觉得这是一个好事，要求高一点，薪资也会高一些。淘汰的，就是一开始就不适合这个行业的人。我目前在一家大型央企工作，还是算较为稳定，但同时也需要不断学习，因为或许某一天的淘汰人选就会是我，社会是残酷的，混日子终究不是一个好的方式。

个人真实经历分享

给大家分享一下我的个人真实经历，与君共勉。

我出生在一个普通的农村家庭，初中开始接触老虎机，高中接触网吧，17岁前没有出过县城，是个十足的井底之蛙，父亲几十年一直在外地工作，一年就回家两三次，从小就我妈妈一个人带我，她做装修的，每天早上7点就骑车外出上班了，下午5点回家，我在家做好饭菜等她回家吃了后，她就马上去田里土里种庄稼，喂了很多牲畜，高中毕业前一直都是这样（不过高中我住校，就我妈妈和我妹在家），我妈妈非常节约，从我记事起，每年只有过年她才会舍得给自己买一两件衣服，因为她觉得过年要穿新的衣服，寓意者新的一年有好的开始，从来没给自己买过首饰，也从来没有烫染过头发，也从来没有赌博过，但同时我父亲其实并不是有责任心的人，基本从不过问家里，以及我的学习。

我的学习打小从小就不好，学习生涯当了两个月的劳动委员，这就是我的荣耀，因为我觉得我小时就是sb，在干啥完全不知道，在学校就是为了吃那一顿饭，和同学天天玩，初中要毕业就被学校各种“”“好言相劝” 去中专学技术，学会拿高薪，实际上是为了赚中专学校的回扣。中专后面又把我们送去富士康，天天12个小时流水线，学校也是为了赚富士康的回扣，我的学业就是这样被卖来卖去，突然觉得有些可悲。这也是普遍读书不行的农村孩子的现状。

我的第一份工作是从2013年开始的，到现在已经差不多10年了，那就做一个时间线看看我的悲催往事吧，这也是我第一次对外讲

2013-2014.02

毕业季，和同学们坐着学校包的几辆大巴车，开到了成都郫县的富士康厂区，哪个时候富士康才在这里建厂，每天的工作就是搬东西，从另外一个地方往厂区里面搬，后面正式开工就开始了每天12个小时的白夜班交替，本来身体从小就弱，经常生病，在富士康就是上班，生病，加上富士康十三跳以及厂区经常出事，我和同学晚上提着东西，连夜翻墙走的，对，真是翻墙走的，后面线长给我打电话，我说我已经不在成都了。不过线长是我老乡，还是跟我没算旷工，算正常离职。 这里不得不说一句，在厂里，一个芝麻官都的官威都不得了，我实在看不惯，加上没前途，才走的。那时候天天12小时到手工资3500，自己上班赚钱还挺潇洒的，下班就去麻辣烫，一人吃饱全家不饿，和同学们啤酒小菜吃着，真是潇洒，厂区还有来自五湖四海的同龄妹子，都是中专生，还是挺快乐的，因为大家年龄相同，就是吃喝玩乐。自然半年才没存什么钱，灰溜溜回了老家，被我妈骂了一顿。

总结：富士康收获： 吃喝玩乐，此刻我的人生规划一无所知

2014.2-2015.07

回了老家，每天早上我妈6点就起来做饭、洗衣服、扫地等等，我起来烧柴，跟猪熬糠羹，喂猪，经常都是公鸡还没叫，我们都忙活一阵了，坚持了十天我就受不了了，因为我得承认，我出去工作后我变懒了，但是每天晚上很晚才睡，因为我在成都买了一个山寨的洛基亚手机，我开始在QQ聊天了，枯燥的生活我受不了，我要出去上班，我就去了重庆。就我妈和我妹两个人在家，这里我的说一下，我去重庆了，我妹才读幼儿园，我妈每天已经非常忙了，我妹从小就是邻居照看，她是位留守的老人，她每天给我妹妹吃好喝好的，比我奶奶好了太多，因为我妈性格很强势，和奶奶性格不合，我奶奶从来没照顾过我和我妹，都在伯伯家带他们的孩子，我妈妈经常晚上8.9点才从田里回家，我妹都是在邻居婆婆那儿吃饭睡觉，前几年她去世了，我妈妈哭了好久，因为她是我家的大贵人，现在每次走到她的坟前，我们都会去跪拜她。现在想起来，我妈太伟大了，她一生都是这么勤劳，吃苦。

到重庆了，上了一年多的厂，其实也是浑浑噩噩的，没有学历，只有在厂里做检验员，一个月2400的工资，入不敷出，因为当时听说主管也是中专学习，干了10多年才当主管，主管才5200一月工资，我觉得没前途，加上厂里玩的好的同事也走了，我也就走了

收获：C1驾-照， 成人高考专科录取通知书， iSO9O001，iSO14001 两个体系证书

2015.7-2016.7

这一年我就像做梦一样，2015年3月去学校报到，认识了班花我老婆，然后就开始交往，然后10月的时候，检查到怀孕了，过年就去了她的老家，因为怀孕了，也就准备结婚的事情了，同学们简直惊叹，纷纷问我怎么办到的？我才23岁，当父亲完全没概念，不过这也满足了我家人的愿望，穷人家里早当家，就在这一年，我妈妈存了一辈子的钱就被我花完了。10月检查怀孕，11月孩子她妈跟我父母說了要了买房买车的事情，我妈妈非常反对，后面我外婆对我妈说：你就这一个儿子，你都不帮他，以后他不恨你吗？ 我妈妈想了几晚她咬咬牙还是同意了，过年去了女方家，她父母挺喜欢我的，我妈妈第二年年初付了房子首付26万，后面装修8万，买车8万，结婚7万，对没听错，全是我妈出的，她平时在农村做装修，有的时候包工，一个月7,8000有的时候包工一万多一个月工资，省吃俭用，全部存下的，都被我全部榨干了，好在岳父岳母没有要我一分彩礼，还给我2万块钱装修，他们也是农村人，也是吃了很多苦，2万得他们在工地干很久了，他们在老家为我们办了十多桌，请了一村的人来吃饭。

我妈后面才跟我说，这么多钱，我爸只出了一万块钱，我现在都不可思议，他在外面这么多年的钱去哪儿了？ 但我也不恨他，毕竟每个人想法不同，他没有义务要给我出这些费用，不过好在之前房子一个平方8000，算是重庆比较贵的房子了，现在26000一个平方，算是赚了一些，有了一个家庭的财产保障，之前还要贵一点，现在房地产不行降了一些。

2016年7月后我出来也是误打误撞的进入了计算机这个行业，我之前压根就不了解这个行业，是看的招聘网站，招聘信息写的5000的工资，我那时候才3000多，在做销售，简直是高薪了，结果去了才知道，原来是计算机培训学校，耐不住那个美女姐姐各种软磨硬泡，我还是去学了计算机，当然，钱还是我妈跟我出的，因为也是孩子她妈跟我妈说这个行业好，比上厂强，我妈才听了她的，要是我说，那根本不管用。

收获：买房，结婚，买车，装修，好像所有的大事这段时间都基本完成了，虽然都是我妈出的钱

2016.7-2018.7

2016年10月孩子出生了，我也从培训学校出来工作了一段时间，培训机构学了4个月，时间都忙家里的事情去了，所以一毕业面试了20多家公司，都被打击了，每次都想放弃，但是回到家，看到家人，我都心里说不出的滋味，为此也哭了好多次，孩子她妈跟着我这些年，没买过一件超过300的衣服，全是淘宝的几十块一件的，我妈妈为了我在农村不管工作有多远，天气有多冷，都要去工作，我觉得我就是累赘，那时我24岁，我压力可能已经超出了我的极限，房贷3000，孩子每个月2000，车子和物业1000，还有生活费，每个月花销都要8000，有的时候孩子一生病就可能要一万以上，我后面找到一份工作4500，是切图仔，每天就jQuery，才稍微帮家里分担了一下，其实压力全部都在我妈妈哪儿，我妈妈为了我，操碎了不少心。

2018年我拿到了大专学历，然后随即开始了报名成人高考本科，孩子她妈就没有报名了，她觉得女孩子大专就够了，加上家里也没钱

收获：
1.当父亲了，压力更大了。我必须得成熟一点了，在前端行业算是正式入行了，通过自己每天工作之外，在各种QQ群里聊天拉业务，我的外快收入也逐渐多了起来，虽然很多时候工作到2点，但是总算是跟家庭减少一点压力，虽然期间换了3家工作，但是我的工资也高了一些，月薪到手9000了，加上外快时多时不多，一个月平均有个1.3的收入了；我也有一点点经济带家人去自驾游了（不过只有两次）
2.成人高考本科录取通知书

2018.7-2020.7

这一年通过我经常在QQ群聊天的好友介绍，我到了一家外包公司（他当时也拿了回扣，但是我也很感激他。因为他教我怎么面试，跟我出面试题），因为通过了客户的面试，我厚着脸皮开到了1.6一个月的工资。到手14k，我当时说我拿这么多，家里人都以为骗他们，不过等发第一个月工资的时候，他们觉得我以前选择计算机是对的，我妈妈也多了很多笑容，这个时候小孩也是大了，妈妈一个人带着孩子读幼儿园，我和孩子他妈在重庆上班，我妈也在上班，家庭算是好了起来，大家笑容也多了起来。当时加上的我的外快业务，一年也能赚个6,7万，因为大家知道我在做这块，后面一些朋友陆续的给我介绍，我也会给他们相对满足的回扣。平均一个月收入已经超过2万了，不过有点不厚道的是，我上班没事也在做外包。

收获：自己随着年龄的增加，人的心态也在发生变化，随着收入多了起来，脸上的笑容也多了，家庭矛盾也少了，日子也越来越有奔头了

2020.7-2023.10

2021年因为公司被客户从人力资源池给移除了，我们没有资格做客户的业务了，我随即也面临着失业，我28岁了，其实我还是很恐慌的，因为家庭开支这么大，加上我长期做外包，技术底子很薄弱，可能失业找不到这么高的工资，所以我很担忧，工作随便都是全日制本科起，我一个半罐子学历，能干点啥，但是后面客户对我的技术能力还有做事能力还算比较认可的，给我推荐了另外还在资源池的外包公司，但是我都不去，我觉得外包没有前途，同时他们也开不起16k的工资（虽然技术不咋的，但是现在是这工资，让我转到其他外包公司才13k,我也心有不甘啊），最后客户他们把我转进了客户内部，于是我一个中专生进入了体制内，不过在进入之前，各部长对我的学历还是有一定质疑，不过我的直系领导以自身名誉担保，我还是通过他们的几轮面试，最终成功进入。进入到体制内，身边的同事都是985的博士，研究生，还有都是留学回来的，也有一些清华北大北航的研究生，其实还是很自卑的，大家学历这么高，有的时候不得不承认，他们的专业素养，学术知识，脑回路都比较灵活，他们的英语都非常厉害，有的同事28岁都上中央台了，太强了，我妈妈非常担心我的学历，怕我一在公司一犯错就被开除，其实有的时候她还是多虑了，我也在尽力 的追赶他们，希望差距尽量小一点点。所以在2023年我拿到了非全的研究生录取通知书，继续读软件工程。在公司也申请入了党，因为他们全是党员，我在公司负责两个部门的前端管理工作，也在带一些校招的研究生，同时我也在2022年5月买了第二套房，首付42万，其他非要加上差不多47万，为此把车卖了一万五，凑点首付钱，我妈妈又出了26万，再一次吧我妈给榨干了，这次我爸也没有出一分钱。不过还在我是组合贷，每个月只出商业贷，每个月出差不多2000的房贷，第一套房贷也还有20多万就还完了，2023年我孩子读小学了，我妈妈也来重庆带孩子了，为此她没有继续在做装修了，每天接送小孩子上学放学，中间有两个小时去一家店里打扫卫生，每个月2500的收入。我在每个月给他2000多生活费，虽然她不太适应城市的生活，觉得城市的人会看不起她是农村人，走哪儿都不会用导航，但是她慢慢的还是习惯了，城市的人并没有觉得自己高人一等，她还算是过得比较快乐，现在我的收入在重庆来说还算OK，外快也有，但是我也不想太累了，我想把时间利用在学习上，因为同事们都很强，我尽量向他们看齐，

收获：本科毕-业-证，非全研究生录取通知书，稳定的工作，第二套房子首付+装修（因为旁边学校更好一点）

最后

今年30了，孩子已经7岁了，我已经开始享受十天的年假了。其实我已经算是走了很多路，深夜哭了很多次，第二天依旧怀揣着斗志，我数次回想我这30年的发展，其实都过得不是很灿烂，或许平凡的就是这样，一无所有的农村人，只能靠父母，如果父母靠不住，那自己也开心点，随着父母的年龄越来越大，我的压力也变大了，他们很多时候会征求我的意见，我也要拿钱支持他们了，也有一些感悟：

1.每年还是得有一个目标，细分到每个月，每一周去完成它，如果没有目标，那就认真的把每一件事情尽量做好，贵人每个人都会遇到，只是看能否抓住，可能会是工作中，生活中的某一个，他愿意提携你一下，真的能少走很多弯路，我的经验告诉我，我有两三次都有贵人帮助我，只是我没有把握住，就像之前一起做区块链，一起做电商的公司老板就很喜欢我，因为我比较踏实，没攻击性，人老实。但是我还是太年轻，很多时候做事不够成熟，就这样和机会擦肩而过，他们现在已经是财富自由了

2.与人交流，说话适可而止，充分尊重他人，聊天中尽量带点幽默，学习一下话题的扩展

3.没事多扩展一下人脉，我才开始培训机构出来，基本没学，全靠在QQ群聊天的人带的我，怎么学，我每次遇到问题我都会问他们，他们在远程帮我改bug，这样我才能保住工作

4.多学习，我看了下我现在的同事，他们没事不会在网上划水，而是都在学习，最敬佩的是旁边那位，一年了从小白，到一名技术骨干，技术成长太快了，他除了学习，每天还不断在看书，我只能说佩服，我很多时候都在刷抖音，我自愧不如，我有罪

5.想办法融入更好的圈子，我之前待得公司都不大，都是外包公司，大家学历都很低，没有一个是985或者211的本科生，大家上班都在聊吃喝嫖赌，主要是聊女人那点事。但是现在我发现身边的同事几年了，没有一个人说过一句脏话，说话总会特别舒服，因为你能感受到他非常尊重你，说话也非常温柔，绝不会听到SEX，tm 这种言词。

6.接受自己的平凡。我以前有很多想法，内心很浮躁，后面发现读书越少的人想法越多，到最后越来越差，债务缠身，本来都是资本的牟利工具，平凡开心更好，把家里的事情处理好，生活上逐渐改善品质，就已经很不错了，在平凡的生活多点浪漫，对未来有一点期待，但不浮夸，我觉得就已经很不错了

7.多多提高自己的综合素质吧，我是一个比较随心的人，但是后面发现，穿的邋遢，说话幼稚，身形不行，走在外面都没自信，何况别人会怎么看你呢，这一点我也在慢慢提高

8.最后我的技术其实很一般，node,vue,react,java,python,php,微信小程序，three.js 这些都有做过,有的都是为了外包业务减少点成本才去学的，但是要说哪一个比较深入，可能就前端的这几个框架，因为天天都在做，偶尔看看掘金的技术文档，但是要说特别深入的，抱歉没有，因为我从误打误撞开始进入这个行业，我的目的不是因为喜欢，而是因为工资高一点，我没有想给要为这个行业带来些什么，我只想活着，我现在觉得我没有特别喜欢做的行业，我不清楚我能在这个行业做多少年，但是只要做，我就把它做好，因为做工作的态度跟自己的喜欢没有关系，做事是做人，自己的工作做好了，下个同事才会很轻松。同时也在尽可能的弥补一些自己的软实力。希望在某一天，有更好的机会，自己能抓得住，自己不会为了自己的能力而自卑！

9.2023-12-21 17:28:53 下班了

有时候会跟着家人去逛菜市场，有次我岳母说北京的菜真贵，原本在农村老家2、3块的黄瓜到了北京要5、6块一斤，感觉真是土气。

出于好奇，我就开始琢磨这个问题。

我问了财务专业的老婆大人，老婆大人的答案很直接，大概意思是北京的供应链比老家贵的多，比如运输成本、用于卖菜的房租成本、还有销售蔬菜的人力成本……然后这些成本都加到蔬菜价格上，自然就高了。

我哈哈一笑，老婆大人的回答自然是不敢出声反驳的，但我可以在心里揣测。我觉得老婆大人说的没问题，但并不深刻，于是我开始浮想联翩……

一 自产自销

在北京生活久了，我发现就蔬菜来说并非不可以自产的。我之前生活的小区，就有销售自产蔬菜的大爷大妈。老婆说是因为供应链比老家的贵，可大爷大妈自产自销不需要供应链啊，老婆的回答就没法解释了。

在我的印象里面，大爷大妈自产的蔬菜也是要比老家的贵的，为什么会如此？

我思考的结果是，大爷大妈是询价定价的。简单来说大爷大妈一开始是不知道定价多少合适的，定的太低心里不得劲，定的太高没人买，所以大爷大妈会去附近菜市场询价，然后定一个比菜市场低的价格，这样既解决了心里不得劲问题，也解决了卖不出去问题。

但这本质上还是因为北京市场上的蔬菜价格比老家的贵。

二 供应链

如果不是自产自销，那就是依靠供应链了。在老家市场销售的黄瓜和北京市场销售的黄瓜，假设有着相同的货源，但背后供应链体系肯定是不同的。

在我们老家有那种大集，就是固定一个时间周期在一个固定地点开展买卖。

大集上的菜农销售蔬菜基本可以忽略掉租房成本，然后因为菜农本身就是销售人员，也省下销售成本，这样整体的供应链成本就下来了，就能够低价销售蔬菜了。

这也就是老婆说的供应链成本不同。

三 边际

边际是经济学核心概念之一，是一种思维方式，就是永远看市场中最后一个人的行为或者最后一个产品的情况。

比如在劳动力市场上，工资不是市场中的平均水平的劳动者决定的，而是最后一个参加劳动的人决定的，要看给他多高的工资他才愿意去做这份工作，同时也要看他有多大的贡献工厂才雇用他，两者相等的时候才是市场里的均衡工资。

拉长时间看蔬菜市场中的黄瓜价格会受边际影响。简单来说，蔬菜超市会因为追求最大经济利益调整蔬菜价格，直到找到均衡价格。

结果因为北京的购买者更能容忍价格的波动，导致北京的黄瓜比农村的贵。

四 可替代性

北京的购买者之所以更能容忍价格波动，原因之一是北京生活的人相对老家农村生活的人，在蔬菜这件事上，可替代性弱。

北京生活的人，少有自产自销者；而农村老家的人，多可以自产自销。这虽然不是价格上涨的直接原因，但无形当中推高了均衡价格。

五 购买力

北京的购买者之所以更能容忍价格波动，原因之二是北京的购买力强。

我之前在小区周边的永辉超市看到有机蔬菜，标记35.98/kg，我当时想什么人会买这种蔬菜呢？

从结果来说，北京购买者购买力强是老家的黄瓜比北京便宜的直接原因。

尾声

黄瓜的价格只是一个小的不能再小的缩影，老家的黄瓜之所以比北京便宜，根本原因是老家农村和北京有着根本不同的经济结构。

北京这种大城市有更高效的资源利用率，更强的生产能力和更高效的生产效率，结果就是北京创造了更多财富，即使普通人在这里也会有较高收入，高收入下基于边际思维演化的黄瓜价格，形成高的均衡价格。

多年前我曾极力劝我一个朋友来北京，他在四线城市很努力，但始终没能赚大钱。当初我说不出更具说服力的让他来北京的理由，但我认为我现在找到了：他赚钱少可能不是因为他不够努力，而是因为他本来就不在一个发达的经济体里，也就难以享受到比较高的红利。

所以我给普通奋斗者的建议是去经济发达地区谋生吧！

1. 引言

平时Android开发中，启动Activity是非常常见的操作，而打开一个新Activity可以直接使用Intent，也可以每个Activity提供一个静态的启动方法。但是有些时候使用这些方法并不那么方便，比如：一个应用内的网页需要打开一个原生Activity页面时。这种情况下，网页的调用代码可能是app.openPage("/testPage")这样，或者是用app.openPage("local://myapp.com/loginPage")这样的方式，我们需要用一种方式把路径和页面关联起来。Android可以允许我们在Manifest文件中配置<data>标签来达到类似效果，也可以使用ARouter框架来实现这样的功能。本文就用200行左右的代码实现一个类似ARouter的简易界面路由。

2. 示例

2.1 初始化

这个操作建议放在Application的onCreate方法中，在第一次调用Router来打开页面之前。

public class AppContext extends Application {

    @Override

    public void onCreate() {

        super.onCreate();

        Router.init(this);

    }

}

2.2 启动无参数Activity

这是最简单的情况，只需要提供一个路径，适合“关于我们”、“隐私协议”这种简单无参数页面。

Activity配置：

@Router.Path("/testPage")

public class TestActivity extends Activity {

    //......

}

启动代码：

Router.from(mActivity).toPath("/testPage").start();

//或

Router.from(mActivity).to("local://my.app/testPage").start();

2.3 启动带参数Activity

这是比较常见的情况，需要在注解中声明需要的参数名称，这些参数都是必要参数，如果启动的时候没有提供对应参数，则发出异常。

Activity配置：

@Router.Path(value = "/testPage",args = {"id", "type"})

public class TestActivity extends Activity {

        @Override

    protected void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        //加载布局...



        String id = getIntent().getStringExtra("id"); //获取参数

        int type = getIntent().getIntExtra("type", 0);//获取参数

    }

}

启动代码：

Router.from(mActivity).toPath("/testPage").with("id", "t_123").with("type", 1).start();

2.4 启动带有静态启动方法的Activity

有一些Activity需要通过它提供的静态方法启动，就可以使用Path中的method属性和Entry注解来声明入口，可以提供参数。在提供了method属性时，需要用Entry的args来声明参数。

Activity配置：

@Router.Path(value = "/testPage", method = "open")

public class TestActivity extends Activity {



    @Router.Entry(args = {"id", "type"})

    public static void open(Activity activity, Bundle args) {

        Intent intent = new Intent(activity, NestWebActivity.class);

        intent.putExtras(args);

        activity.startActivity(intent);

    }



    @Override

    protected void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        //加载布局...



        String id = getIntent().getStringExtra("id"); //获取参数

        int type = getIntent().getIntExtra("type", 0);//获取参数

    }

}

启动代码：

Router.from(mActivity).toPath("/testPage").with("id", "t_123").with("type", 1).start();

3. API介绍

3.1 Path注解

这个注解只能用于Activity的子类，表示这个Activity需要页面路由的功能。这个类有三个属性：

• value：表示这个Activity的相对路径。


• args：表示这个Activity需要的参数，都是必要参数，如果打开页面时缺少指定参数，就会发出异常。


• method：如果这个Activity需要静态方法做为入口，就将这个属性指定为方法名，并给对应方法添加Entry注解。（注意：这个属性值不为空时，忽略这个注解中的args属性内容）

3.1 Entry注解

这个注解只能用于Activity的静态方法，表示这个方法作为打开Activity的入口。仅包含一个属性：

• args：表示这个方法需要的参数。

3.2 Router.init方法

• 方法签名：public static void init(Context context)


• 方法说明：这个方法用于初始化页面路由表，必须在第一次用Router打开页面之前完成初始化。建议在Application的onCreate方法中完成初始化。

3.3 Rouater.from方法

• 方法签名：public static Router from(Activity activity)


• 方法说明：这个方法用于创建Router实例，传入的参数通常为当前Activity。例如，要从AActivity打开BActivity，那么传入参数为AActivity的实例。

3.4 Rouater.to和Rouater.toPath方法

• 方法签名：

1. public RouterBuilder to(String urlString)


2. public RouterBuilder toPath(String path)

• 方法说明：这个方法用于指定目标的路径，to需要执行绝对路径，而toPath需要指定相对路径。返回的RouterBuilder用于接收打开页面需要的参数。

3.4 RouterBuilder.with方法

• 方法签名：

1. public RouterBuilder with(String key, String value)


2. public RouterBuilder with(String key, int value)

• 方法说明：这个方法用于添加参数，对应Bundle的各个put方法。目前只有常用的String和int两个类型。如有需要可自行在RouterBuilder中添加对应的方法。

3.4 RouterBuilder.start方法

• 方法签名：public void start()


• 方法说明：这个方法用于打开页面。如果存在路径错误、参数错误等异常情况，会发出对应运行时异常。

4. 实现

import android.app.Activity;

import android.content.Context;

import android.content.Intent;

import android.content.pm.ActivityInfo;

import android.content.pm.PackageInfo;

import android.content.pm.PackageManager;

import android.net.Uri;

import android.os.Bundle;

import android.text.TextUtils;



import androidx.annotation.Keep;



import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

import java.lang.reflect.Method;

import java.util.Map;

import java.util.Objects;

import java.util.concurrent.ConcurrentHashMap;



@Keep

public class Router {



    public static final String SCHEME = "local";

    public static final String HOST = "my.app";

    public static final String URL_PREFIX = SCHEME + "://" + HOST;



    private static final Map<String, ActivityStarter> activityPathMap = new ConcurrentHashMap<>();



    public static void init(Context context) {

        try {

            PackageManager packageManager = context.getPackageManager();

            PackageInfo packageInfo = packageManager.getPackageInfo(

                    context.getPackageName(), PackageManager.GET_ACTIVITIES);



            for (ActivityInfo activityInfo : packageInfo.activities) {

                Class<?> aClass = Class.forName(activityInfo.name);

                Path annotation = aClass.getAnnotation(Path.class);

                if (annotation != null && !TextUtils.isEmpty(annotation.value())) {

                    activityPathMap.put(annotation.value(), (Activity activity, Bundle bundle) -> {

                        if (TextUtils.isEmpty(annotation.method())) {

                            for (String arg : annotation.args()) {

                                if (!bundle.containsKey(arg)) {

                                    throw new IllegalArgumentException(String.format("Bundle does not contains argument[%s]", arg));

                                }

                            }

                            Intent intent = new Intent(activity, aClass);

                            intent.putExtras(bundle);

                            activity.startActivity(intent);

                        } else {

                            try {

                                Method method = aClass.getMethod(annotation.method(), Activity.class, Bundle.class);

                                Entry entry = method.getAnnotation(Entry.class);

                                if (entry != null) {

                                    for (String arg : entry.args()) {

                                        if (!bundle.containsKey(arg)) {

                                            throw new IllegalArgumentException(String.format("Bundle does not contains argument[%s]", arg));

                                        }

                                    }

                                    method.invoke(null, activity, bundle);

                                } else {

                                    throw new IllegalStateException("can not find a method with [Entry] annotation!");

                                }

                            } catch (Exception e) {

                                throw new RuntimeException(e);

                            }

                        }

                    });

                }

            }

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }



    public static Router from(Activity activity) {

        return new Router(activity);

    }



    private final Activity activity;



    private Router(Activity activity) {

        this.activity = activity;

    }



    public RouterBuilder to(String urlString) {

        if (TextUtils.isEmpty(urlString)) {

            return new ErrorRouter(new IllegalArgumentException("argument [urlString] must not be null"));

        } else {

            return to(Uri.parse(urlString));

        }

    }



    public RouterBuilder toPath(String path) {

        return to(Uri.parse(URL_PREFIX + path));

    }



    public RouterBuilder to(Uri uri) {

        try {

            if (SCHEME.equals(uri.getScheme())) {

                if (HOST.equals(uri.getHost())) {

                    String path = uri.getPath();//note: 二级路径暂不考虑

                    ActivityStarter starter = activityPathMap.get(path);

                    if (starter == null) {

                        throw new IllegalStateException(String.format("path [%s] is not support", path));

                    } else {

                        NormalRouter router = new NormalRouter(activity, starter);

                        for (String key : uri.getQueryParameterNames()) {

                            if (!TextUtils.isEmpty(key)) {

                                router.with(key, uri.getQueryParameter(key));

                            }

                        }

                        return router;

                    }

                } else {

                    throw new IllegalArgumentException(String.format("invalid host : %s", uri.getHost()));

                }

            } else {

                throw new IllegalArgumentException(String.format("invalid scheme : %s", uri.getScheme()));

            }

        } catch (RuntimeException e) {

            return new ErrorRouter(e);

        }

    }



    public static abstract class RouterBuilder {

        public abstract RouterBuilder with(String key, String value);



        public abstract RouterBuilder with(String key, int value);



        public abstract void start();

    }





    private static class ErrorRouter extends RouterBuilder {

        private final RuntimeException exception;



        private ErrorRouter(RuntimeException exception) {

            this.exception = exception;

        }



        @Override

        public RouterBuilder with(String key, String value) {

            return this;

        }



        @Override

        public RouterBuilder with(String key, int value) {

            return this;

        }



        @Override

        public void start() {

            throw exception;

        }

    }



    private static class NormalRouter extends RouterBuilder {

        final Activity activity;

        final Bundle bundle = new Bundle();

        final ActivityStarter starter;



        private NormalRouter(Activity activity, ActivityStarter starter) {

            this.activity = Objects.requireNonNull(activity);

            this.starter = Objects.requireNonNull(starter);

        }



        @Override

        public RouterBuilder with(String key, String value) {

            bundle.putString(key, value);

            return this;

        }



        @Override

        public RouterBuilder with(String key, int value) {

            bundle.putInt(key, value);

            return this;

        }



        @Override

        public void start() {

            starter.start(activity, bundle);

        }

    }



    @FunctionalInterface

    private interface ActivityStarter {

        void start(Activity activity, Bundle bundle);

    }



    @Retention(RetentionPolicy.RUNTIME)

    @Target(ElementType.TYPE)

    public @interface Path {

        String value();



        String method() default "";



        String[] args() default {};

    }



    @Retention(RetentionPolicy.RUNTIME)

    @Target(ElementType.METHOD)

    public @interface Entry {

        String[] args() default {};

    }

}

5. 注意

背景

小盟 AI 助手项目中需要服务端把 AI 模型回调回来内容，实时推送到客户端，展示给用户；整个流程需要一个能够快速支持上线的服务端推送方案。经过对现有的一些服务端推送方案进行调研，并结合项目的周期、实现成本、用户体验等多方综合考量，最终选择了 Server-Sent Events（SSE）方案进行实践。

首先服务端推送，是一种允许应用服务器主动将信息发送到客户端的能力，为客户端提供了实时的信息更新和通知，增强了用户体验。

服务端推送主要基于以下几个诉求：

（1）实时通知：在很多情况下，用户期望实时接收到应用的通知，如新消息提醒、活动提醒等。

（2）节省资源：如果没有服务端推送，客户端需要通过轮询的方式来获取新信息，会造成客户端、服务端的资源损耗。通过服务端推送，客户端只需要在收到通知时做出响应，大大减少了资源的消耗。

（3）增强用户体验：通过服务端推送，应用可以针对特定用户或用户群发送有针对性的内容，如优惠活动、个性化推荐等。这有助于提高用户对应用的满意度和黏性。

方案对比

轮询： 是一种较为传统的方式，客户端定时地向服务端发送请求，询问是否有新数据。服务端只需要检查数据状态，然后将结果返回给客户端。轮询的优点是实现简单，兼容性好；缺点是可能产生较大的延迟，且对服务端资源消耗较高。

长轮询（Long Polling）： 轮询的改进版。客户端向服务器发送请求，服务器收到请求后，如果有新的数据，立即返回给客户端；如果没有新数据，服务器会等待一定时间（比如30秒超时时间），在这段时间内，如果有新数据，就返回给客户端，否则返回空数据。客户端处理完服务器返回的响应后，再次发起新的请求，如此反复。长轮询相较于传统的轮询方式减少了请求次数，但仍然存在一定的延迟。   

WebSocket： 一种双向通信协议，同时支持服务端和客户端之间的实时交互。WebSocket 是基于 TCP 的长连接，和HTTP 协议相比，它能实现轻量级的、低延迟的数据传输，非常适合实时通信场景，主要用于交互性强的双向通信。

SSE： 是一种基于 HTTP 协议的推送技术。服务端可以使用 SSE 来向客户端推送数据，但客户端不能通过 SSE 向服务端发送数据。相较于 WebSocket，SSE 更简单、更轻量级，但只能实现单向通信。

小盟 AI 助手项目需要快速上线且保证要用户较好的使用体验。鉴于 SSE 技术的轻量、实现简单、不增加额外的资源成本；当前业务场景也只需要服务端到用户端的单向的字符推送。非常适合项目需要。所以决定使用 SSE 来实现内容推送。****

深入 SSE

SSE 服务端推送，它基于 HTTP 协议，易于实现和部署，特别适合那些需要服务器主动推送信息、客户端只需接收数据的场景。有以下特点：

1、简单：基于 HTTP，无须额外的协议或者类库支持。主流浏览器都支持。

2、事件流：使用"事件流"（Event Stream）将数据从服务器发送到客户端。每个事件都可以包含一个事件标识符、事件类型和数据字段。客户端可以根据这些信息来解析和处理接收到的数据。

3、自动重连：意外断开时会自动尝试重新连接。可以确保了在网络故障或连接中断后能够及时恢复通信，为用户提供连续的数据流。重连时会在 HTTP 头中的Last_Event_ID 带上上一次的数据 ID，便于服务端返回后续数据。

4、单向推送：只能从服务端推送数据到客户端。

SSE 消息体介绍：

SSE消息体示例：

服务端主要使用 Spring，其对 SSE 主要提供了两种支持：

• Spring WebMVC：传统的基于 Servlet 的同步阻塞编程模型，即 同步模型 Web 框架。


• Spring WebFlux：异步非阻塞的响应式编程模型，即 异步模型 Web 框架。          

项目基于springboot，所以选择使用前者实现。SseEmitter emitter = new SseEmitter(); 一句代码就可以建立一个 SSE 连接。

实践

后端实现

建立一个SseEmitterManger，统一管理当前服务 SSE 连接的创建、释放以及数据推送。结合 Redis 缓存可实现集群环境 SSE 连接的管理。

核心逻辑如下：

• 连接池维护，设定一个上限，避免过大，导致内存问题。

static final Map<String, SseEmitter> sseCache =     new ConcurrentHashMap<>(300)          

• 建立SSE连接，为每个连接建立一个唯一的MsgId，用来维护SSE连接与客户端的关系了；在 Redis 缓存中存入MsgId和当前机器节点的IP和Port，这样可以找到SSE 连接所在的服务结点，然后通过 HTTP 请求转发需要发送的数据到对应的服务节点上进行处理。

sse = new SseEmitter()sseId = "sse_xxx";redisKey= "aisse:" + bosId + "_" + wid ipPort = "10.10.10.10:8080"redis.hset(redisKey, msgId, ipPort)sseCache.put(msgId, sseEmitter);

• 获取持有连接的 pod ipPort；根据 IP 发起请求。

ipPort = redisUtil.hashGet(redisKey, msgId)

• 获取当前服务结点的SSE连接，发送数据。

sseEmitter = sseCache.get(msgId)sseEmitter.send(msgJson)          

• 释放SSE连接

SseEmitter sseEmitter = sseCache.get(msgId);sseEmitter.complete();sseCache.remove(msgId);redisUtil.hashDel(redisKey, msgId);

**核心流程图如下： **  

需要注意的是开启 SSE 连接接口的整个链路都要支持长连接。例如使用 Nginx 则要开启长连接的配置：

• keepalive 用于控制可连接整个 upstream servers 的 HTTP 长连接的个数，即控制总数。


• proxy_http_verion 用于控制代理后端链接时使用的 HTTP 版本，默认为 1.0。要想使用长连接，必须配置为 1.1。


• proxy_set_header 需要设置为 Connection ""，否则则发往 upstream servers 的请求中，Connection header 的值将为close，导致无法建立长连接。   

http {        upstream keepAliveService {            server 10.10.131.149:8080;            keepalive 20;        }            server {            listen 80;            server_name keepAliveService;            location /keep-alive/hello {                proxy_http_version 1.1;                proxy_set_header Connection "";                proxy_pass http://keepAliveService;            }        }}

**前端实现 **  

前端可以使用组件 @microsoft/fetch-event-source 来实现。

npm i @microsoft/fetch-event-source

import { fetchEventSource } from '@microsoft/fetch-event-source';let controller = new AbortController();  let eventSource = fetchEventSource('apiUrl', {  method: 'POST',  headers: {    'Content-Type': 'application/json',    'token': '....'  },  signal: controller.signal,  body: JSON.stringify({    ... // 传参  }),  onopen() {    // 建立连接  },  onmessage(event) {    // 接收信息    // 成功之后满足某些条件可以使用AbortController关闭连接        controller.abort()        eventSource?.close && eventSource.close();  },  onerror() {    // 服务异常        controller.abort()        eventSource?.close && eventSource.close();  },  onclose() {    // 服务关闭  },})

总结

SSE 轻量级的服务端单向推送技术；具有支持跨域、使用简单、支持自动重连等特点。相对于 WebSocket 更加轻量级，如果需求场景客户端和服务端单向通信，那么 SSE 是一个不错的选择。

00后整顿职场，也算是我之前的关键词吧。

我硬怼老板要加班费和提成，和他们辩论什么是我的财产，什么是公司的财产。

甚至还能在即将被开除的时候，反将一军把老板开除。

而正是因为这一次把老板开除，让我得到了机会。可以站在了相对于之前更高的位置，来俯瞰整个职场。

也真正意义上让我感受到了，00后整顿职场，就是一个互联网笑话罢了。

1、职场宫斗，成功上位

我之前在苏州工作，堪称工作中的宫斗，并且在这场宫斗大戏中胜出，将原有的项目负责人开除，成功上位。

而这个项目存在的问题非常多，我就在六月被派遣去项目的总部合肥进行学习，等到打通项目的全部链路后，再回到苏州。

届时我将以这个项目的负责人，重新搭建团队，开展这个项目。所以我在合肥那边，以员工的身份深入各个工作组进行学习。

在市场部，运营部的办公大厅工作过，也在各部门的独立办公室工作过。

我感觉自己像个间谍，一边在以平级的打工人身份和我的同事们相处，一边又以苏州负责人的身份，参与那些领导才能参与的内部会议。

2、内心变化的开端

我在合肥总部工作中，接触了很多躺平摆烂的同事，但这个“躺平摆烂“要加上双引号。

他们是00后，90后，甚至有85后。如果放在三个月前，我可以不假思索地说，他们全都是我最讨厌的人。他们如同牛羊一般任人宰割，上级让加班，他们就加班，有时候加班甚至超过四五个小时也没有怨言。

我甚至从来没听他们感慨过为什么没有加班费。亲眼看着他们被自己的上级用一些与工作无关的鸡毛蒜皮之事骂得狗血淋头，但他们也只会在被骂完之后，背地里吐槽那个领导估计是在家被老婆骂了，才来拿他们泄愤。

我打听了他们的工资，只能说中规中矩，起码不是能让人当牛做马的数字。偶尔我见到一两个有骨气的人，觉得拿这么点钱就应该干这么点事。干不爽就马上离职，但马上就会有下一个人替补他的位置，形成闭环。

我惊讶于怎么有人能惹到这个地步，但后来和他们日渐熟落，我们一起吃饭，一起打游戏，一起下班顺路回家，还参加了他们的生日聚会。我发现他们活得其实真的很洒脱。一切都是随遇而安，下班时间一到，他们就真的可以无忧无虑。

因为他们有一份工资还行的工作，养活自己。他们没有啃老，也没有用卑鄙的手段，去抢想要努力的人应该分到的蛋糕，也压根不去想要赚很多钱，因为没有什么需要太高消费的需求。

加上现在的环境，找到一份可观收入的工作确实很难。所以公司偶尔的加班，领导偶尔的泄愤，这些毕竟还是少数时候的偶尔，也都没有超过他们的心理承受阈值，那也就得过且过了。

所以我们其实都一样，只是个普通人罢了。而像我们这样的普通人，取之不尽，用之不竭。这到底是好事还是坏事呢？

3、复杂的职场生态环境

建立在这个基础上，视觉转换到高层领导们这里。他们当着我的面说，这样的人就是个底层打工仔，缺人就招，加班照旧，心情不好还要扣他们的全勤绩效。

压根就不怕这些底层打工仔闹事，纵使有一两个所谓的决心者辞职，也能在很快时间找到下一位。

两者形成互补，共同铸就了这样恶劣的职场生态环境。但我说职场无法改变，远不止这么一点原因。

在这个项目中，我说好听一些只能算是项目负责人，在此之上还有着项目股东，这还要细分成大股东和小股东。而我所在的项目属于互联网赛道，也就是说需要一些新鲜事物的眼光和思维来对待。

但这些股东们经常提出一些奇怪的意见，就如同用微商时代的卖货思维，来指点直播带货，并且他们是出钱的股东，他们提出的战略方针不容我驳回，因为在他们的光辉历史中，有大量的成功案例，来佐证他们的思路是对的。

我刚开始觉得也有道理。他们能有钱投资，肯定是有什么过人的本领能让他们赚到钱，但是随着相处下来，我发现不过是他们本身家里条件就优越，在九几年就能拿出一百万给他们创业。

他们把这一百万分散到二十个领域，每个投资五万总能撞上那么一两个风口，让他们实现钱生钱。

九几年的五万也算是一笔不少的投资。他们这样的发财经历，让我很难不产生质疑，这不是给我我也行吗？

毕竟他们如果真的有什么过人的本领和远见，也不至于在每次内部开会之前，都要组织喊这样的口号：“好，很好，非常好，越来越好“

甚至试图把这样的口号，带到每一次迎接客户的项目介绍会上。我以自曝式要挟制止他们这个行为，我说如果你们这么干，那我当天就辞职，内部都是自己人，我可以陪你们这样弄，但如果对外这么搞，被录下来说我们是传销，我都不知道怎么辩解。

4、职场中的背锅人

他们就是这样坚信着自己能成功，是因为自己有过人的才华。所以自我洗脑着自己提出的方向没有错。如果出错了，亏损了，那一定是负责人的问题。

但好巧不巧，我就是那个负责人。我已经无数次告诉他们，我们这个项目压根就不需要穿黑丝短裙跳舞的小姐姐。

我甚至写了一篇报告给他们，分析我们的项目为什么不能用擦边这种手段引流。但他们执意要，说这样来流量快，我都有点分不清到底是他们自己想看，还是深信这样做确实是可行。

但如果最后这样还是没成功，导致项目亏损，大概率还是在我身上找原因吧。

面对他们这样的大佬，我心里很清楚，这已经远远不是宫斗了，这也绝对不是靠几个心计，或者有实力撑腰就能取胜上位了。这场权力的游戏，不是我等草民玩得起的。

5、换个思路，创造属于自己的职场

一边是被提供资金，但是瞎指挥的股东们摧残，一边是在有限的预算下，我作为负责人，确实很难做到尊重打工人的内心挣扎，回到苏州我虽然能身居高位，但我终将成为我曾经最鄙视的人。

我不要当这个背锅侠，我也不想在这个环境中，去逐渐接受这样的价值观。

这样看来确实如此，00后整顿职场不过是一场互联网的狂欢罢了。

这个题材的故事，也永远只能发生在职场的最底层。由一群家境优越，体验生活的公子哥和我这种不知好歹的普通人共同出演。

大部分人只是在手机屏幕前把我们当个乐子，成了扣个666，然后一起吃胜利的果实。没成，那就确实是看了个乐子。

或许是因为他们心里也清楚，凭我们压根就做不到。

00后现在确实整顿不了职场，因为社会的资源和命脉还不掌握在00后手上。

但就止步于此了吗？我曾说过我想有一个自己的小工作室，遵守劳动法，双休，按时发工资，交纳五险一金。

是的，换个思路，也许00后不需要整顿职场，而是直接创造属于自己的职场，那么接下来我就要向着这个目标去努力了，毕竟二十年后我也还是00后，不如到时候再来说00后整顿职场吧。

背景原因

今天写需求，需要使用background简写属性，心想这还不简单吗，真男人写样式只需要两秒:

background:  url('./bg.png') no-repeat center contain ;

搞定！

上面设置的依次是 背景图片 背景平铺模式 背景位置 背景图片是保有其原有的尺寸还是拉伸到新的尺寸。

so easy~

看我ctrl + s 保存代码，编译。

嗯？ 怎么不生效？ 俺的背景呢？
打开控制台一看，好家伙，压根没生效:

问题排查

第一反应是这些属性有固定顺序，但是凭我练习两年半的经验，不应该啊，之前也是这样用的啊，遂打开MDN，仔细翻阅....

发现了下面这段话:

这让我更加确信 写的没毛病啊！！

background-attachment、background-color、background-image、background-position、background-repeat、background-size
这些属性可以以任意顺序书写。

见了鬼了,待我排查两小时(摸鱼...)

原因浮现

在仔细阅读文档后发现，其实在文档的上面，还有另外一段话：

我恍然大悟，索嘎，以后看文档不能马虎了，得仔细查阅，过于经验主义了，这都是细节啊！

background使用注意事项和总结

其实，使用background时，大部分时候 属性的顺序是可以任意位置书写的，
但是有两个属性有点特殊，那就是background-size和background-position，

当background简写同时有这两个属性时，那么必须background-position在前，background-size在后，且两者只能紧挨着书写并且以 "/"分隔。
例如:

错误: background: url('./bg.png') no-repeat center  contain ; // 没有以 "/"分隔

错误: background: url('./bg.png') center  no-repeat contain ; // 没有紧挨着书写

错误: background: url('./bg.png') no-repeat contain / center; //background-size写在了 background-position的前面



正确: background: url('./bg.png') no-repeat center / contain ; 

写在最后

其实MDN在关于background的文档最开头的例子中就有写：

只不过没有用语言描述出来，一般没有认真看很难发现，所以有时候能够静下心来认真查阅文档，真的会发现很多细节(甩锅:这tm是谁写的文档，出来挨打).