0. 前言

为了业务线各岗位高效协作，划分职责边界，提升工作效率的同时降低工作强度，减少无效加班的情况。规范工作流程和发版节奏。（不仅适用于互联网，一切团队协作都可参考本SOP，把执行节点进行替换即可）

1. 工作原则

• 一：需求冻结制度

进入开发阶段的需求，非特殊情况，原则上不得变更，新需求一律放入需求池。任何情况下不得口头插入需求。紧急需求必须拉会评审。

• 二：发版节奏固定

每两周为一个迭代周期，发版日固定为每个迭代的最后一个周四。除P0级线上事故外，不允许临时发版。

• 三：各司其职

每项工作有且只有一个「负责人」(Owner)，其他人为「协作者」。负责人对交付质量和进度负全责，协作者配合完成。

• 四：关键环节把控

当工作出现问题，全部要找项目经理协调，原则上不出现策划/产品越过项目经理与研发直接沟通的情况。

• 五：文档驱动

任何情况下，如果要开会，必须撰写文档，不论是技术方案还是产品方案，使用AI辅佐的文档必须自己review先过一遍。

2. 流程与职责边界：

3. 需求变更控制

变更分级

• 轻微变更（文案修改、颜色微调）：开发自行判断可否吸收，报备产品经理即可
• 中度变更（功能逻辑调整、交互修改）：必须提交变更申请，拉相关人员开小会，经产品负责人+技术负责人评审通过后方可执行
• 重大变更（新增功能、砍掉已开发功能）：必须开评审会，评估影响范围和延期风险，由栗子拍板
  紧急需求绿色通道

针对紧急场景，设立专项绿色通道：

1. 提出紧急需求，明确交付时间和核心诉求
2. 产品经理「紧急需求评审会」，明确紧急需求有哪些交付标准和内容（15分钟内完成）
3. 技术负责人评估：当前迭代哪些内容可以交付、哪些必须砍掉、额外需要什么
4. 形成「紧急版本交付清单」：明确列出本次包含/不包含的功能
5. 全员对齐后按清单执行，不得在清单之外临时加内容

声明：本人全篇纯人力手写，无AI成分，或有观感不佳或语法错误，还请谅解。

时间线

一月：加班、春节与重新思考

一月初，因当时所在的业务部门有封闭项目上线，导致一月延续了24年年底的情况，疯狂的加班。有多离谱呢，大概就是隔三差五凌晨四点、五点下班，经常性晚上11点下班，周末没有自由时间，要注意oncall工单和准备各种文档材料来应对年底的绩效打分。

总之在过年前的一月那段日子里，很累，只觉得毫无价值的累，或许大厂的工作免不了如此，但当时我觉得人生不该如此。这也引发了我对这份工作的重新审视，损失健康和个人时间，换来看似体面、相对高薪资的大厂工作真的是我想要的吗？

叠个甲，或许有读者会觉得：“诶呀你都大厂程序员了，肯定赚的多，又想赚得多，又想轻松，怎么可能的事情？你看看底层流水线工人xxxxx，比你累多了还赚的少”。 薪资高低更多是因为市场需求而非个人努力，我只是简单认为所有的工作都不应该牺牲个人健康和空闲时间来换取报酬。牛马不分高低贵贱，苦难就是苦难，苦难不值得任何歌颂与对比，一个月十万的无产者和一个月一千块钱的无产者，本质上是一样的，无非前者运气好点能混个富足的温饱罢了。

一月末，春节，忙碌了一年终于回到了惬意的老家，按惯例和老家的伙伴们聚在了一起，打打台球上上网，搓搓麻将放放火。忙碌一年后，总算稍有喘息。

二月：旅行、看机会与再出发

二月初

大年初一到初七，带一辈子没出过几次省的妈妈，坐飞机，去了云南玩。老妈看到旅途中各种新奇事物与风景的开心，又何尝不是一种独特的风景？

（当然也有一点自豪感，从小山村农村普通家庭走出来的小孩，变得有能力带父母出远门旅行的自豪）另外就是这次旅行后顿觉，人生不仅仅只有生活的苟且和工作的奴役，也有数不尽的有趣等着我们经历。

关于云南我有一篇旅行攻略，感兴趣的朋友可以参考：https://umb.ink/post/38

出发那天妈妈在飞机上，对着窗外景色，看了又看。

大理古城：

（我感觉不如丽江古城，大理古城商业化气息太重了，很无聊）

同行的本地朋友（也是大学死党）的“导管大炮”：

洱海（重量级）：

如果九寨归来不看水，那洱海一定担得起 洱海归来不看湖的美誉。

去洱海，一定要去看日出！！！

双廊的花与洱海的鸥：

渔舟唱晚具象化：

在地热国参加了云南蹦迪：

丽江（古城与雪山）

丽江真是古城里面无敌的存在

非常有故事感的旅拍路人：

很有民族风格的井

早起看的日照金山：

旁边的日落西山：

绝美的饮玉巷

非常好看的无名小巷（古城到处都是，非常耐逛！）

在祈福处的国际友人留下的美好祈愿，第一次切身感受到世界的互相交流。

玉龙雪山（重量级，无敌美！）

雪山下蓝月谷

牦牛坪的远眺：

现场肉眼可见的震撼，见到山的那一刻，旅途的疲惫全无，只剩下对山的震撼。

苍鹰拨开云雾见青天

给朋友拍的游客照：

很有旅人感的照片：

下山后和朋友在古城酒吧里听着民谣研究起了代码：

此时完全不累，甚至非常激动。

或许我们所讨厌的并非工作本身，而是充满了压榨的压抑环境

最后一天，来自俺妹的cos：

三月：决心

年后复工，感觉自己真的要勇敢迈出改变的那一步。碰巧，一朋友在某游戏工作室，恰好缺一个后端，就去简单聊了聊，线下聊的很愉快，当天晚上就给了比较满意的薪酬和待遇。于是决定离开，跳槽。在此前也有不少朋友劝我，劝我再多考虑一下，毕竟在大厂和在游戏工作室的发展还是不一样的。

但人总是要经历的，我很喜欢的LOL职业选手Deft有一句名言：

其实人生在世，并不需要太多别人的建议

因此在年后复工后，我鼓起勇气，还是向领导提出了裸辞。

依然记得签名上标注了lastday的那段时间，合作的同事与业务方，面对我的突然离开，表现得都很惊讶。很多同事和业务方坦白跟我合作的都很愉快，未曾想我突然就要离职了。但天下没有不散的宴席，虽然在大厂一坤年的工作中倍感压力，但确实与很多同事合作非常愉快。只是人总是要向前看的，如果不能适应环境，那不妨鼓起勇气换个环境。

记得很深，有位在其它部门，但一起校招的同届朋友向我诉苦，我走了以后没人听他骂老板了，他那边一年换了两个领导，而且还是阿里来的，很喜欢搞江湖文化，导致他们这些组内“原住民”被边缘化的很惨，新领导安插新嫡系，裁撤老员工，把没人想做的脏活杂活都给他干，导致他的日子也很苦。

离职流程走的很快，从我提出到交接工作到还电脑，也就三周左右，最后一天走的匆匆，交换电脑后，走出园区，那天我没有骑车，难得在离职的下午，一点点晃悠着步行走回了家，重新看了看走了两年半的上班路。

直到当天晚上和朋友吃饭，依然有一种兴奋感，我人生的第一次跳槽，第一次离职，这样的经历真的太令人激动了。

四月：新的开始

4月，来到了新的公司，与新的同事共事，并且工作节奏逐渐步入正轨。

令我惊讶的是，新公司有非常多的“老前辈”，不乏有五十多岁的互联网第一代程序员。

新公司不奉行互联网的优胜劣汰与35岁红线，也不奉行自愿付出，自愿加班的互联网PUA文化，而且愿意以相对优渥的待遇来接纳这些大龄程序员，并且这些老前辈的技术也是相当的扎实，不乏有手搓魔改UE引擎的狠人大佬。

与一帮老员工形成对比的，是公司占了近一半的年轻人，而且都很强，清北毕业和哈理工的同事，也有港中文的博士毕业，团队实力相当雄厚。不过由于老板比较念旧情，还有一部分相对水平没有那么强大的同事，在合作时需要手把手去教他们一些东西，因此偶尔沟通会有点头疼，但除此外都让我感觉，新的工作环境相比于充满压力和PUA的大厂好了不少。

总听别人说互联网压抑，压榨，35岁年龄红线，但某种程度上，确实需要鼓起勇气去外面看看才能知其真假。

小马过河的故事在二十年后依然可以启发每个人。

五月：朋友的婚礼

朋友结婚的日子在五一假期如期到来，第一次参加朋友的婚礼，多少有点激动，虽然24年就已有收到邀请，但真到这一天多少还是有些不一样的感觉。

在婚礼前一天，我们帮朋友布置了婚礼场地，从早布置到晚。

婚礼当天进展还是很快的，很顺利的堵门，游戏，婚宴，然后结束，恍若一梦。

一年到头都难聚在一起的朋友也难得乘此机会好好聚了聚。自从工作后，大家都有各自的人生和路要走，能聚在一起说话的机会越来越难。或许下次再像如此，只能是下一个某某结婚。而当所有人步入下阶段后，或许这段友情也只是记忆的一瞬。

返程路上，有种不太真实的感觉，我还处在问爹妈买什么衣服好看的阶段，我朋友居然已经成家进入下一阶段了。我还在跟朋友约晚上开黑通宵的年纪，朋友居然都一个个订婚了。甚至偶尔刷抖音能刷到以前的初高中同学，他们的孩子已经上幼儿园了。

一种荒诞但又现实的矛盾感。但也或许每个人都要如此经历。

六月：北京

六月值得一说的是把老爹拐到了北京，二十年没出过山西的老爹（年轻时其实也爱玩），总算到北京玩了两天，也留下了两张标准游客照。（值得一说的是老爹年轻也曾走南闯北，但是成家后仿佛蹲了监狱，半辈子再没为了自己潇洒过）

曾无法理解为什么老一辈人总是想办法吃苦，总说为了下一代。但以现在的思维出发，依然觉得老一辈人不必给自己那么大压力，儿孙自有儿孙福，何必执着于为子孙兜底。

人生在世，有些东西不经历是永远不会懂的，与其总想着为下一代兜底，不如让下一代趁着年轻多去经历、多去犯错。

说教无益，折断的骨头才是最好的课本。

七月：洛天依！演唱会！

又一次！洛天依演唱会开到了北京场，叫上了我室友和我妹妹一起，非常nice，体验巨巨好！

另外：偶遇抓到了山新：（演唱会的时候山新就在我侧后方坐着，特别特别幸运！）

八月：日本！

此生第一次出国，从六月就开始计划，定酒店，买机票，办签证，但直到出发坐上飞机的那一刻，我猜真正意识到，我居然要出国了。恍如梦境，放在十年前还在读书的想都不敢想，在ANA航班上，我充满了激动和好奇。

• 当时柜台值机的机票：

  不得不说ANA的机票多少有点简陋了，但激动已经难以克制

从起飞到落地的 Day 1

Day1 落地当天就去了《你的名字》在东京的巡礼。

Day1就这样草草结束，巡礼了君名，去了歌舞伎町（不愧是日式风俗街）。细节就不放了，后续我准备上线一个旅行日记，到时候放在里面（挖坑ing）

Day2-Day3：初音演唱会+秋叶原+东京城市天际线+美军军事基地

（篇幅原因。简单放几张印象深刻的，后续细节我放到旅行相册里，因为实在是太多了，东京接头随手一拍就能出片）
演唱会

秋叶原

东京城市天际线

街景

台场（迪迦 & 数码宝贝取景地）

横须贺美军基地

花火大会！

花火大会随拍

day4–day5：诹访湖

《你的名字》三叶故乡取景地

---

其他

日本乡村景

涩谷十字路口

9-12月

这几个月没有发生什么，只是简单的在工作，推进各个节奏。回味着上半年的种种。

引言

一年又一年。恍惚之间，2025 又匆匆走到了尾声。转眼毕业也将近三年，光阴如隙，来不及细数。

原本想简单聊聊这一年的经历，可细想之下，似乎并没有什么惊天动地的大事。可当真正回头望去，才发现，这一年竟也经历了太多值得铭记的瞬间。

一时语塞，索性就从回顾开始。

关键词

回顾我的 2025，给它一个关键词的话，我会选择——“经历”。

这一年，我经历了工作的变动，住所的迁移，生活环境的改变；也经历了朋友的来来往往，人际关系的靠近与疏远。

乍看之下，好像没有什么轰轰烈烈的大事件，但恰恰是在这些琐碎而具体的小事里，堆叠出了属于这一年的厚度。

它们或许平凡，却真实；或许细碎，却深刻。每一段经历，都留下了一些难忘的回忆，也沉淀出一些值得珍惜的经验。

慢慢地我开始意识到，人生或许并不在于完成多少宏大的目标，而在于去经历那些未曾经历的事情，在经历中体会，在体会中成长。

时间线

篇幅所限，具体的时间线整理在这里：（图比较多，加载图片有可能比较慢，请见谅）
https://umb.ink/post/46

为什么是“经历”？

相比身边的同龄人，我算是比较早进入社会的一批。没有复读，也没有 gap 去考研或考公，毕业后便直接投入工作。再加上一些并不算深厚、却也真实存在的大厂经历，以及偶尔兼职做职业规划、提供咨询的过程，让我有机会接触到形形色色的人，也听到了许多不同的人生故事。

后来慢慢发现——

• 很多迷茫，本质上是因为经历太少；
• 很多焦虑，本质上是因为未知太多。

而“经历”对人的塑造，是极其深刻的。

经历多了，遇事才会坦然。

我曾接触过一些长辈，已近“知天命”的年纪，却在某些问题上依旧像孩童一般。固守旧有观念，排斥新鲜事物；面对未知时慌张无措，甚至本能地抗拒改变。

• 年龄，并不天然带来成熟；
• 时间，也不会自动转化为见识。

真正让人沉稳的，从来不是年岁，而是经历。

当你见过足够多的选择，听过足够多的故事，踩过足够多的坑，你自然会明白——很多事情不过如此，很多焦虑也终将过去。

于是，2025 对我而言，不是“成就”的一年，而是“经历”的一年。
而经历，本身，就是一种成长。

经历越多，越能看清自己，也才能真正成长。

在做咨询的时候，我常会遇到两类极端的朋友：
一种是“优越感爆棚”，一种是“妄自菲薄”。

最典型的，是前者。

有些自身条件并不占优的人，却常常说：

“非大厂配不上我，不去。”

“年薪不到 30 万没必要工作。”

“我才不要做销售，不体面。”

“人要对自己好一点，贷款也要买车。”

这些话听起来像是自信，甚至像清醒，但——真的如此吗？

不可否认，每个人都有自己的价值观。但从我接触过的许多人和故事来看，过度的自我优越，往往来源于缺少真实挫折的经历。

他们未必家庭富裕，却往往被父母尽力托举。父母替他们承担了生活的重量，他们却从未真正感受过生活的重量。
于是，在缺乏参照与碰撞的情况下，容易高估自己的能力，同时低估现实的门槛。

更矛盾的是——
一旦真正进入社会，面对赤裸裸的竞争与筛选，这种“理想自我”和“真实自我”的落差，会在瞬间崩塌。
很多人会从自负直接跌入自卑，甚至难以承受压力，走向极端。

而另一类人恰恰相反。他们常说：

“我配不上。”

“我什么都不会，肯定找不到工作。”

“我还是听父母的，去流水线踏实一点吧。”

这些人往往成长于压迫感更强的环境。父母能力有限却控制欲强，从小被否定、被比较、被要求“懂事”。
长期的评价体系让他们形成强烈的“不配得感”——即使别人认可，他们也难以相信。

于是做事畏缩，机会面前先退一步。

鼓励可以短暂提振，却无法真正改变，因为问题不在认知，而在经历的缺失。

仔细观察会发现，这两种看似相反的性格，本质却相同——

• 都没有经历过足够真实、足够匹配的反馈。

如果自负的人，从小被引导去直面困难，他可能会成为真正自信的人；

如果自卑的人，拥有几次可验证的成功体验，他的成长速度往往极快。

所以人的发展，很像“小马过河”。
别人告诉你深浅没有意义，只有自己试过，河才有刻度。

经历越多，能力边界才会清晰：

面对超出能力的事敢于挑战，面对能力之内的事游刃有余。

因此，多经历——
无论好事坏事，都是成长的组成部分。

任何经历，都是一堂生动、珍贵的一课

仔细回想，前些年在大厂加班加的死去活来的经历，初到北京被街道办强拆出租屋的经历，找工作时被内卷疯狂PUSH的经历，恋爱时吵的不可开交的经历，高考时学习学到昏天黑地的经历....这些在当时的我看来都是生活带给我的一些“苦难”，但从现在的我看来，这些都是生活教会给我的珍贵一课。

• 大厂的加班让我学会了如何提高自己的工作和协作效率，也更加明白了身体最重要。
• 虽然被强拆了出租屋，但也第一次学会了冷静面对突发意外，学会了如何与不讲理的老登回旋。
• 找工作的内卷让我明白了自己的上限在哪里，也明白了量变一定会引起质变。
• 恋爱的矛盾让我明白了如何与异性相处，如何处理好思维方式差异导致的矛盾。
• 高考时的苦难学习让我在日后遇到艰苦的环境时，会下意识想，“这算啥，高考早五晚十都经历过了”。
• 北漂的生活虽苦，但是让我认知和见识涨了非常多，也让我第一次意识到，人可以舍弃所有所谓的“责任”，去追寻自己所想的未来。（当然，也可以说提升了幸福感，毕竟对比之下，没有什么比小镇做题家从0开始北漂更苦的事情了）

经历越多，路也会越走越宽。

偶尔朋友会打趣我：“你怎么总能听到这么多故事，而且很多还挺惨的？”

这其实是个因果倒置：
幸福的人往往不需要倾诉；
不幸的人，需要出口。

很多故事之所以沉重，是因为它们必须被说出来，否则当事人就要独自承担全部重量。

也许正因为我平时会帮人做规划，也喜欢聊一些“歪理”，不少人遇到事情会来找我聊聊。

于是虽然我很宅，却认识了很多人；
我经历不多，却听过很多故事。
而这些间接的经历，同样在塑造一个人。

后记

回头看，2025 并没有发生什么决定命运的大事。
但我开始理解一件事：

成长不是因为某个瞬间改变了人生，

而是经历让你慢慢不再需要改变人生。

这一年不是“有所成”的一年，

而是第一次不再着急“有所成”的一年。

而经历，本身，就是答案。

新年愿望

身体健康

升职发财

去一趟欧洲旅行

去新疆旅行

学会一首完整的双手钢琴曲

看到更多、更美好的故事

引言

这篇文章主要写给还没毕业或刚刚毕业的同学，希望通过这篇文章，能够让大家从学生思维跳脱出来，向真正的工程师思维进行转变，更好地提升自己。

学生思维和工程师思维有什么区别？为什么要转变？

我们说的工程师思维不仅仅是局限于做工程师的人，而是拥有像工程师一样解决问题的能力，推进项目落地的思维方式。

在学生时代，我们习惯了“老师布置什么，我就做什么”的学习模式——作业按要求完成、考试按范围复习，这种“等待指令”的思维惯性让知识接收高效运转，但是不会主动思考去解决问题，过度关注局部/短期的事物，这就是我们常说的“学生思维”。而工程师思维与之不同，工程师思维强调自己探索，从全局角度整体思考，要具有能够独立解决复杂问题的能力。相比学生思维，工程师思维更加严谨，更加主动。

进入社会、跨入职场后，我们需要主动解决问题的能力，需要有从全局角度思考的综合性思维。因此学生思维是无法帮助我们继续成长的，我们要从“知识接收者”到“问题解决者”的角色转型。

举个例子：
现在学校里面要做一套校园门禁系统，并且校长把这个项目交给你来做，此时你会如何着手？

如果是普通学生，会想如何设计门禁硬件，可能会用esp32做门禁闸机板，可能会用java写后台门禁管理系统，但大部分情况下，当学生按这个思维设计下去之后会发现，做出来的东西完全不能用，也不好用，项目也推不动。这是因为学生思维惯性，只关注到了“门禁系统”这一个具体的局部系统，而不是整个项目。做项目，做工程不仅仅只有浮于表面的硬件设备或代码平台，还包括了上下游一系列的用户和利益相关方，包括了对项目未来可能会存在的一系列风险的预估。这些是学生思维所无法涵盖的。

而对于有一定成熟经验的工程师，“门禁系统”在设计时，会考虑很多前置问题，它的受众群体到底包括哪些人？如何让学校内的每个人都能接受新的门禁系统？如何与相关方高效沟通？在硬件选型上，如何保证闸机运行的稳定性？供电、网络稳定性如何保证？项目推进时需要涉及哪些校内部门，需要和哪些领导打交道？这些全部确认后，后续才是如何着手落实这个项目。

因此，学会工程师思维，能够帮助我们跳脱出认知困境，站在全局角度思考问题，更好地推动问题解决或项目落地，也可以更好地辅助我们做完美的决策。

如何转变？

1. 改变环境

拥有工程师思维离不开真正的“工程师环境”，也就是要在实际的工程化环境，真正致知于行，才能更好的学习和培养工程师思维。在学校这个相对与社会隔绝的环境中，很难有机会接触到真正的落地项目。

有些同学可能参加各种创新创业大赛，做一些打比赛的项目，甚至是做一些小规模的校内创业项目，这些项目虽然一定程度上可以帮助我们初步积攒一些经验，了解到一定量的工程化思想。但是跟实际的公司、社会环境中的落地项目相比，依然相差甚远。

因此，在个人能力满足的情况下，我建议大家多多出去到社会企业中进行调研、实习，哪怕去到比较底层，非常草台班子的初创公司。特别是前往科技较为发达的一线、新一线城市去，实习，工作。真正切身实地感受与人沟通、规划资源、学习职场前辈的各种工作方法论，在这个过程中逐渐培养起工程师思维，一点点升级打怪。

大家需要明白一个事情，学校能教的有且只有书本和老师PPT上的内容，非常有限，学校不会教你文档怎么写，PPT如何做，如何与人沟通，如何快速解决问题等等，只有切身到真正的社会中，才能学会这些东西。正如古话所言纸上得来终觉浅，绝知此事要躬行。

2. 学会自我寻找答案

在程序员的职业发展中，有一个文章叫做“提问的智慧”，是所有程序员的必修课，而我认为这是所有人的必修课，每个人都应该学会“如何向别人提问”，学会自我解决问题，学会如何正确从他人那里获取知识。

自我解决问题与向他人寻求答案并不冲突，自我解决问题的过程中，合理向他人寻求帮助也是一种很好的方法，但是这不代表所有事情都要依赖于他人，向他人寻求答案的本质是将答案转变为自己的能力。如果一味地依赖他人，不自己探索，那么问题永远存在，永远不属于自己。

那么如何学会自我探索，自我寻找答案呢？

1. 用好搜索引擎/AI问答：搜索引擎和AI是一个非常强大的工具，有任何疑问，先从搜索引擎寻找答案，推荐谷歌、其次是bing，最不推荐百度（百度害人，很容易出现一个问题搜索下去一整页全是广告）
2. 使用思维导图，梳理问题链路。在遇到问题时先梳理问题关系，对问题进行拆解，尝试多多使用思维导图和流程图，去寻找问题关键点。举例：我要找工作，那么我就要从头梳理我找工作这个问题，首先我想要什么工作？然后我的期望薪资是什么?我的能力有哪些？我预期的工作岗位要求有哪些？将这些问题作为一个个思维图进行导出，然后寻找他们之间的关联。

3. 举例：我通过拆解“我要找工作”这个问题来绘制思维图。把一堆生涩的招聘要求和我个人的能力直观地呈现出来，寻找之间的关联，更好地让我能够看到我的短板和我的长处。

3. 多模仿，多看多做

不论是在校园内，还是在社会中，在我们身边一定有很优秀的人，他们思维敏捷，做事雷厉风行，那么他们就是我们学习的榜样。我们可以多多观察这些人在工作时，在沟通时的行为逻辑和方式，甚至可以自己悄悄进行记录或大胆与他们单聊请教，了解他们的思维方式和学习方式（当然，前提是方式要合理，要尊重别人）。而与优秀的人聊天，每每都会给我们不同的新启发。并且很多优秀的人也非常乐于分享自己的经验和经历，与优秀的人沟通一定是一件对自我提升很大的事情。

吸纳不同人的思维，学习不同人的做事方式，最终转变为自己的风格，长此以往，不知不觉中我们将会也变成别人口中“优秀的人”。

但需要注意的是，不是所有人思维逻辑都适合无脑学习，一定要结合自己的实际情况。东施效颦不可取。

适度去拓展眼见

认知，眼见的拓展也是褪去学生思维的一大核心，当自己的眼见拓宽，会看到很多不同的事物，而思想也会更加全面，更加容易找到问题切入点。

例如在大学生时期，很多人不会把“图书管理系统”当回事，觉得这种东西只是很简单的一个课程设计级别的CRUD系统，但倘若真正见识过企业级的图书管理系统，就完全不会这样想，企业级的图书管理系统要考虑稳定性，考虑易用性，考虑数据安全，服务稳定，可能作为学生不会觉得服务宕机几分钟或者丢失一些数据是什么大事，但在企业层面，几分钟的服务不可用可能就是数百万不可挽回的损失。而倘若没有真正见过几分钟亏损几百万的场面，大多数学生是无法想象到服务稳定性是多么重要的一件事。

因此，适度地去参加各种科技展会，技术沙龙，开拓自己的眼见（甚至可以适当地放弃一些校内课程来参加各类科技展会），我相信展会带来的眼界拓展一定比学校的落后课程的作用更大。

结语

最后我想说，从学生思维到工程师思维的转变，从来不是一蹴而就的瞬间蜕变，而是一场需要耐心与实践的长期修行。当我们放下"等待指令"的惯性，开始主动扛起解决问题的责任；当我们跳出课本里的标准答案，学会在现实的复杂约束中寻找最优解——这种思维方式的进化，不仅会让我们在职场中走得更稳，更会成为我们终身成长的底层能力。

记住，真正的工程师思维，不只是写代码、做项目的专业技巧，更是一种"把不可能变成可能"的信念。它教会我们在迷雾中找到方向，在阻力中开拓路径，在质疑中坚持价值。或许起步时会有笨拙与迷茫，但每一次主动思考、每一次解决问题、每一次突破认知边界，都会让我们离"优秀工程师"的目标更近一步。

愿你从此刻开始，带着这份思维的"工具箱"，勇敢地走向更广阔的世界。不必害怕犯错，不必焦虑速度，因为每一次实践都是蜕变的契机。当你真正用工程师的眼睛审视世界，用工程师的双手改变现实，你会发现：成长，永远比想象中更精彩。

1. 打开你的cursor，选择setting->network->选择http1.1

setting在界面右上角

2. 打开你的魔法工具的全局代理模式，然后cursor就正常了。

什么？你不知道什么是魔法工具？你可以退出程序员这个行列了。

背景

最近接手了一个新游的架构设计，因为新游偏向社交类游戏，单个游戏体内会存在多人联机、多种不同类型游戏对局的交互，即要考虑多种不同玩法服务的兼容和多人联系情况下的稳定性。

问题

传统的C/S架构中，可以一定程度上容忍server侧的变更或者某个实例突发宕机的情况（大不了重新请求一下就好了），但游戏架构要求多人联机场景下的稳定性和兼容性，无法容忍游戏联机过程中server中某个实例突发宕机或扩缩容的情况，因为当一个容器突发宕机，那就意味着那个容器上的游戏对局将会受到影响，严重影响用户体验。

我们先来看看使用C/S架构开发游戏的架构模式：

从这个架构中可以明显看出下面的这些问题：

1. 数据同步链路长：在一场对局中，传统C/S架构下，每个客户端WS所连接的Server实例可能不一样，并且同一个对局内的数据流同步必须依赖中间件进行，数据流传输链路长，高负载请求下，可能出现延迟感知明显的问题。
2. 稳定性不足：假如某个实例宕机，此时对应的用户会突然断开连接并丢失部分操作请求，影响对局进程。
3. 延迟较高：客户端可能分布在世界各地，每个客户端到服务的延迟都不同，在多人游戏对实时性要求较高的情况下，不同的游戏延迟会导致用户感知到的对局数据不同，影响游戏体验
4. 开发/维护成本较高：即使在不同的游戏模式下，都需要单独在不同模式的游戏serevr中实现相同的对局、房间管理逻辑，而客户端需要根据不同的游戏模式去连接不同的对局服务器，额外增加成本。

DS

没有什么是设计一个中间层解决不了的。面对多人联机社交游戏场景下的服务设计，我们引入DS服务层的概念来解决这个问题。

DS，全称叫做Dedicated Server（专用服务器），它可以用来给多人联机时提供稳定的房间信息管理和对局进度管理以及用户客户端的WS连接管理，并且一定程度上可以降低我们多游戏业务的开发成本。

那么我们来引入DS看下引入DS之后的架构：

DS优势

可以看到，引入DS之后，每个游戏客户端所连接的WS服务节点由DS统一调度管理，提高整个系统的可维护性。

1. 在同一个对局内，每个客户端连接的对局服务器在同一个实例上面，这样可以最大程度减少数据同步带来的性能损耗。

2. 数据会在DS内部的cache实例上缓存，假如在对局运行中某个DS实例崩溃，那么此时DS网关可以快速将实例上的所有连接转到其他实例，并从cache中把相关数据load到新实例里面，在用户端的感知也仅仅只是短暂断线重连，而且作用于同一对局内的所有用户，可以保证游戏对局进程影响最小化。

3. 得益于DS收束了所有的WS代理连接，那么我们就可以支持游戏客户端在一个游戏场景中，同时使用多个游戏WS服务，而客户都只感知到了一个WS数据流，多个WS客户端有DS实现WS映射。

例如：在一个游戏场景中，存在房间管理的WS、用户上下线的WS、用户沟通消息RTC信令、游戏玩法的对局数据WS等多个WS连接点，有DS的接入，客户端只需要接入一个DS的ws即可，如下架构图：

引言

  近来多与身边的朋友或网友闲聊，发现大家在25岁前后的这个阶段，在聊起人生目标与计划时，很多都丧失了“心气”，尽显颓势，感受不到年轻人应有的激情。

  这倒并不能说错，每个人都有自己的人生追求与规划。只是这令我感到比较疑惑，在25岁这个年纪，原本应当积极向上，朝气蓬勃的年纪，却总给人一种已经年过花甲的释然、沉闷和随时等死的“丧气感”。

  网上近些年也有个段子很火，精力充沛的老年人和死气沉沉的年轻人，应该让老年人替年轻人上班，年轻人替老年人退休。

  这不禁让我思考，为什么我们年轻人都失去心气了？

先问是不是，再问为什么

  我偶然会与身边身处各个人生阶段的同龄朋友沟通，在我的留意下，尚且还在上学的，心气最足，幻想着未来的一切可能。毕业后两年的，心气最弱，不乏已经有将“老婆孩子热炕头”作为人生终极理想、混吃等死作为人生规划的。毕业两三年依然在啃老，做着“考公、考研、考编”三部曲来逃避人生的也大有人在。

  毕业后在北京北漂了两年的我，在西二旗这个牛马聚集地，也见识到了诸多的无奈。大厂中拿着几十万甚至百万年薪的打工人，终此一生的目标是背上天价的贷款，在北京买套房，甘愿被公司压榨自己的健康与时间，生活中只剩下了工作与睡觉（有的连睡觉都不能满足）。

  当问及这些北漂打工人的人生目标与规划时，许多人含糊不清，好似除了上班已经再无其他说的出口的生活。为了在北京落户买房，然后呢？背上30年的房贷，每个月60%的工资全部拿去还房贷，剩下的勉强够温饱。当房贷还完，人已暮年，坐等西去。

  当然，每个人都有自己的的人生规划与活法，我们无权对他人的生活规划指指点点，只讨论大家为什么失去心气这个问题。至少我认为，我们的生活不应该只有无休止的工作，我们的理想不应该是为了在忙碌的大城市求得一隅安置，我们的目标不应该只是为了生存。

环境问题

   到这里可能大家会思考一个问题，是我不想去追求梦想吗？是我不想休息吗？是我要生存呀。那这就归到了一个客观因素上，国内目前的工作环境极其苛刻，有班上的人，面对的是无时无刻的劳动力压榨和职场PUA；没有班上的人，面对的是日趋增长的物价和逐渐贬值的存款。因此，大家不得不去内卷、去把自己的生命献给资本家，去用自己的梦想、自己的健康、自己的未来 换回在社会中能够短暂生存的资源。

当"生存"成为人生主旋律时，"生活"便成了橱窗里的奢侈品。我们不得不正视一个残酷的现实：在经济增速放缓与阶层固化加剧的双重挤压下，年轻人陷入了"高学历-高负债-低幸福感"的莫比乌斯环。大学毕业前，所有人都在告诉年轻人，说他们未来可期，是最幸福的一代，鸡娃教育也从小就告诉年轻人，大学念完就轻松了，就熬出头了，但是从来没有人告诉年轻人，真正的社会是什么样的。当温室的花朵怀揣从课本上了解到的片面知识进入残酷的社会，极大的落差是令很多人无法接受的。

许多985院校的毕业生的第一份工作很多也只能勉强覆盖北京单间租金，在北京能得温饱，这种结构性的经济压力，让"诗与远方"在生存算术题面前显得格外苍白。在这种生存的落差下，年轻人所追求的美好生活与心气，自然日趋减少，甚至开始对生活祛魅，对理想祛魅，逐渐向往当下的享乐与逃避躺平。

价值观问题

当婚恋市场用房产证丈量人生价值，就业市场只看每个人的剩余可压榨价值，那些关于艺术创作、社会创新或自由职业的人生规划，往往被贴上"不务正业"的标签，整个社会都弥漫着畸形的价值观，一个人生来要 内卷、上学、补习班、遵纪守法然后听从号召结婚、养家、背债、消费、养娃。

总之社会希望底层的普通人是什么样，那就要是什么样。当社会需要普通人进厂时，那我们就要脱下孔乙己的长衫进厂打工。当需要普通人为家庭付出时，那我们就要早早结婚，身负房贷，掏空积蓄支付彩礼、首付，身下孩子身上父母，我们的行为和价值观永远只能被普罗社会所裹挟，至于年轻人自己？谁在乎。再加上短视频吃人血馒头的营销号们无孔不入，不断放大这些畸形的价值观，强烈的不适感不断裹挟着我们这代人。

持续多变的畸形价值观与年轻人朝气蓬勃，充满理想的价值观格格不入，在剧烈的冲突下，面对生存的压力，家庭的压力，另一半的压力，不得不低头。但是这就好像没有人喜欢上班一样，强迫一个人接受他不愿意接受的事物和观念，自然会磨损心理。

教育问题

我们上一代人，特别是上一代的基层父母，大多认知相对短浅（毕竟也没资源去见世面），保守封建，鸡娃倾向严重，忽略孩子的生长环境和心理健康培养。这种教育模式培养出的年轻人，往往在人生前二十年的成长中只学会了两件事：服从权威与参与竞争。

从小学到高中的十二年间，学生被切割成无数个标准化零件，在"提高一分干掉千人"的残酷竞争中，逐渐将人生价值等同于分数和排名。当这些年轻人走出象牙塔后却发现，社会竞争的维度远比试卷上的选择题复杂得多。

更致命的是，基础教育与社会需求存在严重的结构性错位。高校专业设置与产业升级速度严重脱节，特别是很多高校不思进取，很多教辅资源还是几年前甚至十几年前的内容。

以我读的计算机专业为例，大学很多教材里面的内容还是上个世纪的内容，还在教非常落后的技术（能教spring boot已经是非常先进的内容了），而我们的时代需要的是各种新兴生产力。整天在大学中教授老掉牙的东西，却又希望学生早日找到一份好工作，这合理吗？

很希望我们的大学老师能够走出象牙塔，真正地去社会公司里面体验下新兴的技术是什么样的，我指的不是去跟旅游一样去人家公司参观，而是真正以一个技术人才的角度去入职，去体验公司里面的技术需求和各类流程，好好思考一下社会所需要的到底是什么样的人才。

学生作为信息闭塞的一方，带着自己大学四年积攒的令其自豪的知识进入社会，发现社会早就淘汰了老掉牙的知识，这个时候学生又会受到多大的打击？长此以往，自然心气大受打击甚至有些极端的年轻人在进入社会后选择自暴自弃，草草结束坎坷的一生。

破局

有的年轻人并非喜欢低迷的心气，更多只是对现实生活的无奈，但又寻求不到破局的方法。这里结合博主自己的一些经历谈谈我的看法。

1. 阶段性享受，摈弃常态化高压工作：

我并不推崇享乐主义，相反我认为享乐主义不可取。但常态化高压工作更不可取，适度让自己享受一下，去听许久期待的演唱会、去看从小想去看的世界、去做任何想做的事情，不要害怕花钱。

我们大部分都是底层人，几乎不可能靠加班和努力跨越阶级，不断地高压工作只会折损自己的精神状态和身体健康，那不如阶段性地放下一切去讨好自己，天是塌不下来的。月赚三千照样生活，月赚三万也照样生活，不追求结婚养娃，人生在世，只为活自己就好。什么？你说未来生病急需钱用怎么办？那就去死呗，年轻享受年老早死难道不是一件幸事吗？。

对自己任性一点，其实90%的人活着也对社会没什么特别大的价值，我们是社会的边角料，但却是自己的全部，所以对自己好一点，以实现自己的人生价值为第一优先，至于别的，爱咋咋地。

2. 端正自己的位置，屁股决定脑袋：

屁股决定脑袋，如果你是富二代，那你就去做富二代该做的事情，去想富二代该想的事情。如果你是底层的普通人，那你就多关心自己的事情，关心明天吃什么，关心家里人健康如何，关心自己该做什么。而不是整天替老爷们担心社会经济怎么样，公司怎么样，你是打工人那就关心自己怎么样能做好工作，早日升职加薪。端正自己的位置，不考虑自己改变不了的事情。

或许，有的人会说，那些我无法改变的事情会影响我自己的工作和生活。那又如何呢？即使担心也无法改变不是吗？养成一个思维链：这个事情和我有没有关系？-> 这个事情会不会影响我的正常工作生活-> 这个事情我可以改变吗？ -> 如果有一个答案是否定的，那这个事情你没必要思考。顺其自然爱咋咋地，天塌不下来，只要死不了都是小事，你都没有办法的事情，担心也没用。

另外，明确自己适合做什么也很重要，也就是说要对自己的能力和认知有一个清晰了解。比如我目前是一名程序员，技术还不错，做全栈工程师或者架构师，那我在这个阶段就不考虑自己能力以外的事情，不对自己能力以外的东西投入过多的精力。我赚程序员这份钱，我就不专门投入精力考虑怎么赚自媒体的钱，因为我认为我目前的能力与性格不适合去做，只会凭空消耗自己的精力。再比如我是一个大学生，我技术能力很强，但是我不爱说话，而且不喜欢理论知识，只喜欢实践。那我就绝对不考虑考研考公，而是去钻研技术，进入大厂。

但是，明确自己的适合做什么这是一个阶段性动态变化的变量。比如我现在在做架构师，但是随着业务扩张，我可能要开始带团队，逐渐有了带团队的经验，那么这个时候，对自己的认知也要进行更新，我就不仅仅适合做架构师，我这个适合也可以尝试去做管理了。一味地固步自封，不更新对自己的认知，只会踌躇不前。

3. 不考虑任何沉没成本，学会及时止损：

学会接受损失，比如我谈了一段恋爱，这段恋爱持续了七八年，但是这个期间我在感情里面得不到任何快乐，只有内耗，但是又舍不得这么多年的感情，只能摸摸忍受。你以为分手是葬送了前几年的努力，其实不然，分手是把自己推向了一个新的起点而不是回到原点。只有接受这段感情的失败，及时止损，才有重新开始的机会。

很多事情也是这样的道理，再比如我在一家公司干的并不快乐，天天被脑残老板PUA、加班，但是碍于在公司呆了很多年，离职很亏，但是不离职只会不断地继续被压榨，直到某天被公司当作废物耗材一脚踢掉。及时止损，马上换赛道，就会有新的起点和机会。

因此在发现自己有沉没成本而影响自己做某个决策时，学会忽略所有的沉没成本，接受已有的损失，前往新的起点。

4. 不对任何人寄托任何期望：

明确自己是自己的主角，你活着没人在意你，你死了也没什么人为你悲伤，每个人都有自己的生活和人生。别觉得任何人就应该对你怎么样，就应该怎么样，没有人欠你的，也没有人生来就对你好，也没有人百分百会按你的期望发展。不要将任何期望寄托在别人身上，平等地将所有人认为不可靠，把关注点回到自己，去关注自己的能力提升和认知提升才是核心。

攻略说明

本攻略侧重云南自然风光游玩，轻人文景观（古城等），因此仅供想要侧重游玩自然风光的进行参考

涉及地点

云南北线攻略：昆明-大理-丽江，以大理与丽江为主，昆明走马观花

因为六天五夜时间比较紧张，其实完整北线应该是 昆明-大理-丽江-香格里拉

核心地点：大理洱海、大理古城、丽江古城、玉龙雪山风景区、昆明滇池

预算：旺季人均2k（不算机票与自购特产）

时间安排：

1. 第一天 落地昆明，然后前往大理，先游玩大理古城（第一天下午+晚上），晚上可以在大理古城附近吃傣味手抓饭体验，逛到晚上10点可以打车前往酒店入住。

2. 第二天 在龙龛码头看日出，然后骑电动车环游洱海西岸，裳苍山雪。

• 码头日出：

• 苍山雪：

• 洱海西岸：

3. 第三天 包车或自驾游洱海东岸，游双廊古镇，看鹿卧山，小普陀。下午在东岸看洱海日落，晚上前往丽江。

• 双廊古镇：

• 鹿卧山：

4. 第四天 在丽江古城早起看古城的日照金山（需要碰运气），全天游古城，晚上可以去古城酒吧一条街体验丽江古城的民谣酒吧。

5. 第五天 包车或自驾前往玉龙雪山风景区，凌晨出发，早上可以到东巴谷看日照金山，然后进入山区上大索道（如果抢不到票去中索道牦牛坪也很不错），下山后坐景区大巴前往蓝月谷。

玉龙雪山脚下：

牦牛坪：

6. 第六天 早起返回昆明，时间充裕可以去海洪湿地公园看滇池海鸥，然后去翠湖公园看郁金香，如果还有时间推荐斗南花卉市场。

路线安排：

注意：建议不要携带行李箱，因为路途遥远且各个景点之间相距甚远，行李箱会非常不方便，最好做背包客，一个背包解决所有问题。

• 第一天：

  早上飞机落地昆明，走马上任前往大理。昆明-大理 动车约一个半小时，约下午三点到达大理。

  大理站到大理古城可以坐大理旅游观光线路大巴，途中会经过兴盛大桥，到达兴盛大桥可以下车打卡，下午刚好是打卡的好时候。

下午和晚上在大理古城游玩，玩够了可以骑共享电动车前往酒店入住（注意千万不要租古城附近的电动车，否则你还需要回来还车）。

• 第二天：

早起去看龙龛码头的日出（注意可能人会很多，建议提早去占位置），龙龛古渡的观景台上有“上关花、下关风、苍山雪、洱海月”四个石碑，可以打卡。

日出回来可以吃个早餐，洱海附近很多卖烤饵块早餐的。然后可以租个车在洱海西岸游玩。

• 第三天

洱海东岸环线

旺季建议在东岸包车（注意，不要包本地人车行的车，非常贵而且坑），建议打一个滴滴，然后咨询师傅能不能包他的车，直接找网约车师傅包车会更便宜（没有中间商赚差价）而且很多都是本地人，比导游更了解哪里好玩。

淡季建议租车（不堵车的洱海东岸值得自驾）

• 第四天

从大理到丽江，可以在大理选择直达丽江古城的大巴车（70每人）经济实惠，也可以坐高铁直达。

到达丽江后可以打车到丽江古城（如果是大巴会直接送到古城门口）

• 第五天

玉龙雪山（记住提前一周抢票！！！）玉龙雪山分为大索道-上雪山、中索道-上牦牛坪、小索道-去云杉坪

去之前建议在古城购买一瓶氧气（十块钱）千万不要到了景区再买，景区都是几百一瓶。

尽量不要在古城购买一日游套餐！体验非常差。导游会忽悠你去买高价氧气，租用很烂的那种保温服。

在雪山如果准备去蓝月谷的话，不要坐观光车，直接乘坐景区通勤大巴到蓝月谷的下一站，可以直接徒步，体验更好。

• 第六天

从丽江坐高铁返回昆明返程，路上会经过洱海，可以留意下火车窗外的风光。

整理下在工作中常用到的各种ADB命令和一些工具方法

ADB指令（常见）

1. 隐藏/恢复系统的菜单栏和任务栏

   隐藏：

   adb 导出文件到PC
   

adb pull /sdcard/xxxx/ .

8. 打开设备浏览器并访问对应网址

adb shell am start -a android.intent.action.VIEW -d https://baidu.com

9. 启动/停用设备自身adb端口

设置应用为主屏幕应用

应用授权启动

设置音量

重启应用

eboot;

工具类&方法

静默安装

class InstallAPK {
    companion object {

        const val timeOut = 5 * 1000L
        private const val MD5_APPEND0 = "0"
        private const val MD5_STRING = "MD5"
        private const val SHA1_NAME = "SHA1"
        private const val TAG = "InstallAPK"
        /**
         * install slient
         *
         * @param context
         * @param filePath
         * @return 0 means normal, 1 means file not exist, 2 means other exception
         * error
         */
        fun installSlient(filePath: String, packName: String): Int {

            val file = File(filePath)
            if (!file.exists()) {
                return 1
            }
            var args: Array<String>
            if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
                args = arrayOf("pm", "install", "-r", "-i", packName, "--user", "0", filePath)
            } else {

                args = arrayOf("pm", "install", "-r", filePath)
            }
            val processBuilder = ProcessBuilder(*args)

            var process: Process? = null
            var successResult: BufferedReader? = null
            var errorResult: BufferedReader? = null
            val successMsg = StringBuilder()
            val errorMsg = StringBuilder()
            var result: Int

                process = processBuilder.start()
                successResult = BufferedReader(InputStreamReader(process!!.inputStream))
                errorResult = BufferedReader(InputStreamReader(process.errorStream))
                var s: String?

                do {
                    s = successResult.readLine()
                    if (s != null) {
                        successMsg.append(s)
                    } else
                        break
                } while (true)

                do {
                    s = errorResult.readLine()
                    if (s != null) {
                        errorMsg.append(s)
                    } else
                        break
                } while (true)

                    successResult?.close()
                    errorResult?.close()


                process?.destroy()

            if (successMsg.toString().contains("Success") ||
                successMsg.toString().contains("success")
            ) {
                result = 0
            } else {
                result = 2
            }

            return result
        }
        /**
         * 获取apk的包名
         */
        fun getApkPackageName(
            context: Context,
            apkPath: String?,
        ): String? {
            apkPath ?: return null
            val pm = context.packageManager
            val info = pm.getPackageArchiveInfo(apkPath, 0)
            return info?.packageName
        }


        /**
         * MD5加密
         * @param byteStr 需要加密的内容
         * @return 返回 byteStr的md5值
         */
        private fun encryptionMD5(byteStr: ByteArray?): String {
            var messageDigest: MessageDigest? = null
            val md5StrBuff = StringBuffer()
            try {
                messageDigest = MessageDigest.getInstance(MD5_STRING)
                messageDigest.reset()
                messageDigest.update(byteStr)
                val byteArray = messageDigest.digest()
                //            return Base64.encodeToString(byteArray,Base64.NO_WRAP);
                for (i in byteArray.indices) {
                    if (Integer.toHexString(0xFF and byteArray[i].toInt()).length == 1) {
                        md5StrBuff.append(MD5_APPEND0).append(
                            Integer.toHexString(
                                0xFF and byteArray[i]
                                    .toInt()
                            )
                        )
                    } else {
                        md5StrBuff.append(Integer.toHexString(0xFF and byteArray[i].toInt()))
                    }
                }
            } catch (e: NoSuchAlgorithmException) {
                e.printStackTrace()
            }
            return md5StrBuff.toString()
        }

        /**
         * 获取app签名md5值,与“keytool -list -keystore D:\Desktop\app_key”‘keytool -printcert     *file D:\Desktop\CERT.RSA’获取的md5值一样
         */
        fun getSignMd5Str(context: Context, packageName: String): String {
            try {
                val packageInfo: PackageInfo = context.packageManager.getPackageInfo(
                    packageName, PackageManager.GET_SIGNATURES
                )
                val signs: Array<Signature> = packageInfo.signatures
                val sign: Signature = signs[0]
                return encryptionMD5(sign.toByteArray())
            } catch (e: PackageManager.NameNotFoundException) {
                e.printStackTrace()
            }
            return ""
        }

        private fun hexDigest(bytes: ByteArray?): String? {
            val md5: MessageDigest = try {
                MessageDigest.getInstance(MD5_STRING)
            } catch (e: java.lang.Exception) {
                e.printStackTrace()
                return ""
            }
            val md5Bytes = md5.digest(bytes)
            val hexValue = StringBuffer()
            for (i in md5Bytes.indices) {
                val `val` = md5Bytes[i].toInt() and 0xff
                if (`val` < 16) hexValue.append(MD5_APPEND0)
                hexValue.append(Integer.toHexString(`val`))
            }
            return hexValue.toString()
        }

        /**
         * 从APK中读取签名
         *
         * @param file
         * @return
         * @throws IOException
         */
        @Throws(IOException::class)
        private fun getSignaturesFromApk(strFile: String): ByteArray? {
            val file = File(strFile)
            val jarFile = JarFile(file)
            try {
                val je: JarEntry = jarFile.getJarEntry("AndroidManifest.xml")
                val readBuffer = ByteArray(8192)
                val certs: Array<Certificate>? = loadCertificates(jarFile, je, readBuffer)
                if (certs != null) {
                    for (c in certs) {
                        return c.encoded
                    }
                }
            } catch (ex: java.lang.Exception) {
                ex.printStackTrace()
            }
            return null
        }

        /**
         * 加载签名
         *
         * @param jarFile
         * @param je
         * @param readBuffer
         * @return
         */
        private fun loadCertificates(
            jarFile: JarFile,
            je: JarEntry?,
            readBuffer: ByteArray,
        ): Array<Certificate>? {
            try {
                val inputStream: InputStream = jarFile.getInputStream(je)
                while (inputStream.read(readBuffer, 0, readBuffer.size) !== -1) {
                }
                inputStream.close()
                return je?.certificates
            } catch (e: IOException) {
                e.printStackTrace()
            }
            return null
        }
        
        /**
         * 校验已经安装的软件签名是否和插件市场下发的软件签名一致
         * @param localPkgName 已经安装的包名
         * @param path 插件市场下发的软件路径
         */
        fun checkSign(context: Context, localPkgName: String, path: String): Boolean {
            try {
                val pathMD5 = hexDigest(getSignaturesFromApk(path))
                val localPkgNameMD5 = getSignMd5Str(context, localPkgName)
                LogUtils.i("$TAG pathMD5: $pathMD5")
                LogUtils.i("$TAG localPkgNameMD5: $localPkgNameMD5")
                if (TextUtils.isEmpty(localPkgNameMD5)) {
                    LogUtils.i("$TAG isEmpty")
                    return true
                }
                LogUtils.i("$TAG isSame: ${pathMD5 == localPkgNameMD5}")
                return pathMD5 == localPkgNameMD5
            } catch (e: java.lang.Exception) {
                e.printStackTrace()
            }
            return false
        }

        private fun allowDowngrade(sessionParams: PackageInstaller.SessionParams) {
            try {
                //允许低版本安装的原因：在新版本出问题但是来不及修复需要进行版本回退
                val allowDowngrade: Method = PackageInstaller.SessionParams::class.java.getMethod(
                    "setAllowDowngrade",
                    Boolean::class.javaPrimitiveType
                )
                allowDowngrade.isAccessible = true
                allowDowngrade.invoke(sessionParams, true)
            } catch (e: java.lang.Exception) {
                e.printStackTrace()
            }
        }
        @JvmStatic
        fun installApk21(context: Context, apkFilePath: String): Boolean {

            val apkFile = File(apkFilePath)
            if(apkFile.exists())
            {
                LogHelper.saveRequestLog("$apkFilePath, 文件存在")
            }else{
                LogHelper.saveRequestLog("$apkFilePath, 文件不存在")
            }
            val packageInstaller = context.packageManager.packageInstaller
            val pkgName = getApkPackageName(context, apkFilePath)
            LogHelper.saveRequestLog("InstallAPK apk path:$apkFilePath, package name:$pkgName")


            pkgName?.let {
                //如果签名不一致则先卸载
                if (!checkSign(context, pkgName, apkFilePath)) {
                    LogHelper.saveRequestLog("InstallAPK apk package uninstall")
                    uninstallSignError21(context, pkgName, apkFilePath)
                }

                val sessionParams = PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL)
                    .apply {
                    setAppPackageName(pkgName)
                    setSize(apkFile.length())
                }
                allowDowngrade(sessionParams)
                val sessionId = createSession(packageInstaller, sessionParams)
                if (sessionId != -1 && copyApkFile(packageInstaller, sessionId, apkFilePath, it)) {
                    return install(
                        context,
                        packageInstaller,
                        sessionId,
                        InstallReceiver::class.java
                    )
                }
            }
            LogHelper.saveRequestLog("Install falied")
            return false
        }

        /**
         * 最后提交 session，并且设置回调
         **/
        @JvmStatic
        fun install(
            context: Context,
            packageInstaller: PackageInstaller,
            sessionId: Int,
            cls: Class<*>
        ): Boolean {
            var session: PackageInstaller.Session? = null
            try {
                LogHelper.saveRequestLog("start install")
                session = packageInstaller.openSession(sessionId).apply {
                    val intent = Intent(context, cls)
                    val pendingIntent =
                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                            PendingIntent.getBroadcast(
                                context,
                                1, intent,
                                PendingIntent.FLAG_MUTABLE
                            )
                        } else {
                            PendingIntent.getBroadcast(
                                context,
                                1, intent,
                                PendingIntent.FLAG_UPDATE_CURRENT
                            )
                        }
                    commit(pendingIntent.intentSender)
                }
                return true
            } catch (ex: Exception) {
                LogHelper.saveRequestLog("Install falied exception:${ex.message}")
            } finally {
                session?.close()
            }
            return false
        }
        
        /**
         * 根据 sessionParams 创建 Session
         **/
        @JvmStatic
        fun createSession(
            packageInstaller: PackageInstaller,
            sessionParams: PackageInstaller.SessionParams,
        ): Int {
            val sessionId: Int = try {
                packageInstaller.createSession(sessionParams)
            } catch (e: IOException) {
                e.printStackTrace()
                -1
            }
            return sessionId
        }

        /**
         * 将 apk 文件输入 session
         **/
        @JvmStatic
        fun copyApkFile(
            packageInstaller: PackageInstaller,
            sessionId: Int, apkFilePath: String, pkgName: String,
        ): Boolean {
            var success: Boolean
            val apkFile = File(apkFilePath)
            try {
                packageInstaller.openSession(sessionId).use { session ->
                    session.openWrite(pkgName, 0, apkFile.length()).use { out ->
                        FileInputStream(apkFile).use { input ->
                            LogUtils.d("$TAG copyApkFile openWrite start writing ${apkFile.absolutePath}")
                            var read: Int
                            val buffer = ByteArray(1024)
                            while (input.read(buffer).also { read = it } != -1) {
                                out.write(buffer, 0, read)
                            }
                            session.fsync(out)
                            syncFile2Disk()
                            success = true
                        }
                    }
                }
            } catch (e: IOException) {
                LogUtils.e(e.stackTraceToString())
                success = false
            }
            LogUtils.d("$TAG copyApkFile openWrite writ done! success = $success")
            return success
        }

        private fun syncFile2Disk() {
            try {
                CmdUtil.execCmdSilent("sync")
//            Shell.SH.run("sync")
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
        @JvmStatic
        private fun uninstallSignError21(context: Context, pkgName: String, apkFilePath: String) {
            try {
                runBlocking(Dispatchers.IO) {
                    LogUtils.d(">>> InstallAPK apk package name:$pkgName sign diff $apkFilePath")
                    uninstall21(context, pkgName)
                    //给卸载一些时间 5秒
                    delay(timeOut)
                }
            } catch (e: java.lang.Exception) {
                e.printStackTrace()
            }
        }
        @SuppressLint("MissingPermission")
        @JvmStatic
        fun uninstall21(context: Context, pkgName: String) {
            LogUtils.d(">>> InstallAPK uninstall21 pkgName = $pkgName")
            val packageInstaller = context.packageManager.packageInstaller
            val intent = Intent(context, InstallReceiver::class.java)
            val pendingIntent =
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                    PendingIntent.getBroadcast(
                        context, 2, intent,
                        PendingIntent.FLAG_MUTABLE
                    )
                } else {
                    PendingIntent.getBroadcast(
                        context, 2, intent,
                        PendingIntent.FLAG_UPDATE_CURRENT
                    )
                }
            try {
                packageInstaller.uninstall(pkgName, pendingIntent.intentSender)
            } catch (e: IllegalArgumentException) {
                e.printStackTrace()
            }
        }

        fun installSilence() {
            
        }
        
        fun installSilentWithReflection(context: Context, filePath: String?,packName: String) {

                val packageManager = context.packageManager
                val method: Method = packageManager.javaClass.getDeclaredMethod(
                    "installPackage",
                    *arrayOf<Class<*>?>(
                        Uri::class.java,
                        IPackageInstallObserver::class.java,
                        Int::class.javaPrimitiveType,
                        String::class.java
                    )
                )
                method.setAccessible(true)
                val apkFile = File(filePath)
                val apkUri: Uri = Uri.fromFile(apkFile)
                method.invoke(packageManager, arrayOf(apkUri, object : IPackageInstallObserver.Stub() {
                    @Throws(RemoteException::class)
                    override fun packageInstalled(pkgName: String, resultCode: Int) {

                    }
                }, 2, packName))
        }
    }
}


获取设备各种基本信息（部分需要root）

object DeviceInfoUtil {
    private const val maximumPassengerPref = "maximum"
    @SuppressLint("HardwareIds")
    fun getSN(): String {
        //return "e0d8c45adef0"
        return Build.SERIAL
    }

    fun isNetworkAvailable(context: Context): Boolean {
        val connectivityManager =
            context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        if (connectivityManager != null) {
            val activeNetworkInfo: NetworkInfo? = connectivityManager.activeNetworkInfo
            return activeNetworkInfo != null && activeNetworkInfo.isConnected()
        }
        return false
    }

    fun getSN(context:Context):String{
        var androidId: String =
            Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID)
        if(androidId.isNullOrBlank())
        {
            try {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                    androidId = Build.getSerial()
                } else {
                    androidId = Build.SERIAL
                }
            }catch (e:Exception){

            }
        }
        if(androidId.isNullOrBlank())
        {
            try {
                val telephonyManager =
                    context.getSystemService(TELEPHONY_SERVICE) as TelephonyManager
                androidId = telephonyManager.imei
            }catch (e:Exception){

            }
        }
        return androidId
    }

    fun getMacAddress(): String {

        var macAddress=""
        try {

                val all: List<NetworkInterface> =
                    Collections.list(NetworkInterface.getNetworkInterfaces())
                for (nif in all) {
                    if (!nif.name.equals("eth0", ignoreCase = true)) continue
                    val macBytes = nif.getHardwareAddress() ?: return ""
                    val res1 = StringBuilder()
                    for (b in macBytes) {
                        res1.append(String.format("%02X:", b))
                    }
                    if (res1.length > 0) {
                        res1.deleteCharAt(res1.length - 1)
                    }
                    macAddress = res1.toString()
                }
        } catch (ex: Exception) {
            // Handle exception
        }


        return macAddress // Default MAC address if not found
    }


    fun saveRequestLog(data:String)
    {
        try {
            var formatter: DateFormat = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
            var formatter2: DateFormat = SimpleDateFormat("yyyy-MM-dd")
            val time: String = formatter.format(Date())
            val fileName = "request-${formatter2.format(Date())}.log"
            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                val sdCardPath = Environment.getExternalStorageDirectory();
                val path = sdCardPath.getAbsolutePath() + "/TVAgent/logs"
                val dir = File(path)
                if (!dir.exists()) {
                    dir.mkdirs()
                }
                var content =
                    "Time:[${time}]---${data}\n"
                val file = File("${path}/${fileName}")
                val raf = RandomAccessFile(file, "rw")
                val originalContent = ByteArray(raf.length().toInt())
                raf.readFully(originalContent)
                raf.seek(0)
                raf.write(content.toByteArray())
                raf.write(originalContent)
                raf.close()
            }
        }catch (ex: IOException)
        {

        }
    }


    fun getStorageInfo():String {
        val statFs = StatFs(Environment.getRootDirectory().getPath())
        val blockSize = statFs.blockSizeLong
        val totalBlocks = statFs.blockCountLong
        val availableBlocks = statFs.availableBlocksLong
        val totalSpace = totalBlocks * blockSize
        val availableSpace = availableBlocks * blockSize
        return (availableSpace.toDouble()/totalSpace.toDouble()).toString()
    }

    fun readCPUStat(): LongArray {
        try {
            BufferedReader(FileReader("/proc/stat")).use { br ->
                val line = br.readLine()
                if (line != null && line.startsWith("cpu")) {
                    val tokens =
                        line.split("\\s+".toRegex()).dropLastWhile { it.isEmpty() }
                            .toTypedArray()
                    val user = tokens[1].toLong()
                    val nice = tokens[2].toLong()
                    val system = tokens[3].toLong()
                    val idle = tokens[4].toLong()
                    val iowait = tokens[5].toLong()
                    val irq = tokens[6].toLong()
                    val softirq = tokens[7].toLong()

                    saveRequestLog("读取cpu信息:user:${user} nice:${nice} system:${system} idle:${idle} iowait:${iowait} irq:${irq} softirq:${softirq}")
                    // 包含所有CPU时间的数组
                    return longArrayOf(user, nice, system, idle, iowait, irq, softirq)
                }
            }
        } catch (e: IOException) {
            saveRequestLog("读取cpu信息异常:${e.message}")
        }
        return LongArray(0)
    }


    fun getSystemMemoryInfo(context: Context):String {
        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
        val memoryInfo = ActivityManager.MemoryInfo()
        activityManager.getMemoryInfo(memoryInfo)
        var totalMemory=0L
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
            totalMemory = memoryInfo.totalMem
        }
        val availableMemory = memoryInfo.availMem
        val lowMemory = memoryInfo.lowMemory // 设备当前是否处于低内存状态
        return (availableMemory.toDouble()/totalMemory.toDouble()).toString()
    }

    fun getIP(): String {
        val interfaces = NetworkInterface.getNetworkInterfaces()
        while (interfaces.hasMoreElements()) {
            val networkInterface = interfaces.nextElement()
            val addresses = networkInterface.inetAddresses
            while (addresses.hasMoreElements()) {
                val address = addresses.nextElement()
                if (!address.isLoopbackAddress && address.hostAddress.indexOf(':') < 0) {
                    return address.hostAddress
                }
            }
        }
        return ""
    }

    fun getVersionType(context: Context): Int {
        val sharedPreferences = context.getSharedPreferences("version", Context.MODE_PRIVATE)
        return sharedPreferences.getInt("version_type", 0)
    }

    fun setVersionType(context: Context, versionType: Int) {
        val sharedPreferences = context.getSharedPreferences("version", Context.MODE_PRIVATE)
        val editor = sharedPreferences.edit()
        editor.putInt("version_type", versionType)
        editor.apply()
    }

    fun getVersionName(context: Context): String? {
        val packageManager = context.packageManager
        val packageInfo: PackageInfo
        var versionName: String? = ""
        try {
            packageInfo = packageManager.getPackageInfo(context.packageName, 0)
            versionName = packageInfo.versionName
        } catch (e: PackageManager.NameNotFoundException) {
            e.printStackTrace()
        }
        return versionName
    }

}


应用执行ADB Shell指令

public class CmdUtil {
    // 执行adb shell并获取返回字符串
    public static String execCmd(String cmd) {
        String result = "";
        String line = "";
        try {
            Process proc = Runtime.getRuntime().exec(cmd);
            InputStreamReader is = new InputStreamReader(proc.getInputStream());
            BufferedReader br = new BufferedReader(is);
            while ((line = br.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    // cmd="chmod 777 /dev/ttyACM"
    public static int execRootCmdSilent(String cmd) {
        int result = -1;
        DataOutputStream dos = null;

        try {
            Process p = Runtime.getRuntime().exec("su");
            dos = new DataOutputStream(p.getOutputStream());
            dos.writeBytes(cmd + "\n");
            dos.flush();
            dos.writeBytes("exit\n");
            dos.flush();
            p.waitFor();
            result = p.exitValue();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (dos != null) {
                try {
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }

    public static int execCmdSilent(String cmd) {
        int result = -1;
        DataOutputStream dos = null;

        try {
            Process p = Runtime.getRuntime().exec(cmd);
            dos = new DataOutputStream(p.getOutputStream());
            dos.writeBytes("exit\n");
            dos.flush();
            p.waitFor();
            result = p.exitValue();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (dos != null) {
                try {
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }



    public static void rebootSystem(Context context) {
        LogUtils.v("Reboot", "Reboot-->broadcast_reboot");
        try {
            Intent intent = new Intent(Intent.ACTION_REBOOT);
            intent.putExtra("nowait", 1);
            intent.putExtra("interval", 1);
            intent.putExtra("window", 0);
            context.sendBroadcast(intent);
        }catch (Exception e) {
            LogUtils.e(e);
        }

    }

    @SuppressLint("HardwareIds")
    public static String getDeviceSN(Context context) {
        String serialNumber = System.getProperty("persist.sys.boardsn.value", null);
        if(serialNumber == null) {
            serialNumber= Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
        }
        return serialNumber;
    }

    public static String callCmd(String cmd, String filter) {
        String result = "";
        String line = "";
        try {
            Process proc = Runtime.getRuntime().exec(cmd);
            InputStreamReader is = new InputStreamReader(proc.getInputStream());
            BufferedReader br = new BufferedReader(is);

            while ((line = br.readLine()) != null
                    && line.contains(filter) == false) {
                result += line;
            }

            result = line;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

}



网络信息相关获取

class NetworkInfoUtil(val context: ReactContext) {
    var ipv4: String = ""
        get() {
            return field.apply {
                refreshIp()
            }
        }
    var ipv6: String = ""
    val TAG = "network"
    var bssid = ""
    private val request: NetworkRequest = NetworkRequest
        .Builder()
        .addTransportType(
            NetworkCapabilities.TRANSPORT_WIFI
        ).build()
    var mac: String = ""
    private var connMgr = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager



    /**
     * 用于Android12 以下获取IP
     */
    private fun refreshIp() {
        try {
            val en: Enumeration<NetworkInterface> = NetworkInterface.getNetworkInterfaces()
            while (en.hasMoreElements()) {
                val intf: NetworkInterface = en.nextElement()
                val enumIpAddr: Enumeration<InetAddress> = intf.inetAddresses
                while (enumIpAddr.hasMoreElements()) {
                    val inetAddress: InetAddress = enumIpAddr.nextElement()
                    if (inetAddress.isLoopbackAddress) {
                        continue
                    }
                    LogUtils.d("WifiPreference", inetAddress.hostAddress)
                    if (inetAddress is Inet6Address) {
                        LogUtils.d("ipv6", inetAddress.hostAddress)
                        ipv6 = inetAddress.hostAddress as String
                        continue
                    }
                    if (inetAddress is Inet4Address) {
                        LogUtils.d("ipv4", inetAddress.hostAddress)
                        ipv4 = inetAddress.hostAddress as String
                        continue
                    }
                }
            }
        } catch (ex: SocketException) {
            LogUtils.e("WifiPreference IpAddress", ex.toString())
        }
    }

    fun getMacAddress(): String {
        val wm = context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager?
        if (wm != null) {
            val winfo = wm.connectionInfo
            if (winfo != null) {
                val s = winfo.bssid?: ""
                LogUtils.d("mac", s)
                return s
            }
        }
        return ""
    }
    fun isLocationEnabled(): Boolean {
        var locationMode = 0
        val locationProviders: String
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            locationMode = try {
                Settings.Secure.getInt(context.contentResolver, Settings.Secure.LOCATION_MODE)
            } catch (e: Settings.SettingNotFoundException) {
                e.printStackTrace()
                return false
            }
            locationMode != Settings.Secure.LOCATION_MODE_OFF
        } else {
            locationProviders = Settings.Secure.getString(
                context.contentResolver,
                Settings.Secure.LOCATION_PROVIDERS_ALLOWED
            )
            !TextUtils.isEmpty(locationProviders)
        }
    }
    fun getSSID(context: Context, callback: Callback) {
        val wifiManager = context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager?
        if (!wifiManager!!.isWifiEnabled) {
           callback.invoke("")
           return
        }
        if (wifiManager != null) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                val mRequest: NetworkRequest = NetworkRequest.Builder()
                    .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                    .build()
                val mConnectivityManager: ConnectivityManager = context.applicationContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
                val mNetworkCallback = object : NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
                    override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
                        super.onCapabilitiesChanged(network, networkCapabilities)
                        val wifiInfo = networkCapabilities.transportInfo as WifiInfo?
                        var ssid = ""
                        wifiInfo?.let {
                            ssid = wifiInfo.ssid.replace("\"", "").replace("<", "").replace(">", "")
                            LogUtils.d("ssid", ssid)
                            mConnectivityManager.unregisterNetworkCallback(this)
                        }
                        try {
                            callback.invoke(ssid)
                        }catch (e: Exception){
                        }
                    }
                }
                mConnectivityManager.registerNetworkCallback(mRequest, mNetworkCallback)
            } else {
                val connectionInfo = wifiManager.connectionInfo
                if (connectionInfo?.networkId != -1) {
                    var ssid = connectionInfo?.ssid?.replace("\"", "")
                    callback.invoke(ssid)
                }
            }
        }
//        return ssid
    }

    // 获取系统LocationMode的值
    fun getLocationMode(): Int {
        // 返回值是0 的时候, 就是 LOCATION_MODE_OFF 这个宏
        //  返回值为1的时候 就是 LOCATION_MODE_SENSORS_ONLY 就是上面的仅限设备GPS
        //  返回值是2, 就是 LOCATION_MODE_BATTERY_SAVING 低耗电量
        //  返回值为3, 就是 LOCATION_MODE_HIGH_ACCURACY 仅限设备
        var locationMode = 0
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            locationMode = try {
                Settings.Secure.getInt(context.contentResolver, Settings.Secure.LOCATION_MODE)
            } catch (e: Settings.SettingNotFoundException) {
                LogUtils.e("getLocationMode", e.message)
                e.printStackTrace()
                return 0
            }
            locationMode
        } else {
            0
        }
    }

    fun getScanWifiEnable(context: Context): Boolean {
        val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager?
        return locationManager!!.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
    }

    fun getSSID(context: Context, callback: (ssid: String?)-> Unit) {
        val wifiManager = context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager?
        if (!wifiManager!!.isWifiEnabled) {
            callback.invoke("")
            return
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
            val mRequest: NetworkRequest = NetworkRequest.Builder()
                .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                .build()
            val mConnectivityManager: ConnectivityManager = context.applicationContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val mNetworkCallback = object : NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
                override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
                    super.onCapabilitiesChanged(network, networkCapabilities)
                    val wifiInfo = networkCapabilities.transportInfo as WifiInfo?
                    var ssid = ""
                    wifiInfo?.let {
                        ssid = wifiInfo.ssid.replace("\"", "").replace("<", "").replace(">", "")
                        LogUtils.d("ssid", ssid)
                        mConnectivityManager.unregisterNetworkCallback(this)
                    }
                    try {
                        callback.invoke(ssid)
                    }catch (e: Exception){
                    }
                }
            }
            mConnectivityManager.registerNetworkCallback(mRequest, mNetworkCallback)
        } else {
            val connectionInfo = wifiManager.connectionInfo
            if (connectionInfo?.networkId != -1) {
                var ssid = connectionInfo?.ssid?.replace("\"", "")
                connectionInfo.bssid?.let {
                    bssid = it
                }
                callback.invoke(ssid)
            }
        }
//        return ssid
    }
    private fun initNetwork() {
        when (Build.VERSION.SDK_INT) {
            Build.VERSION_CODES.S -> {
                val obj = object : NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
                    override fun onLinkPropertiesChanged(
                        network: Network,
                        linkProperties: LinkProperties
                    ) {
                        super.onLinkPropertiesChanged(network, linkProperties)
                        for (addr in linkProperties.linkAddresses) {
                            LogUtils.d("ip", addr.address.hostAddress)
                            if (addr.address is Inet6Address) {
                                LogUtils.d("ipv6", addr.address.hostAddress)
                                ipv6 = addr.address.hostAddress as String
                                continue
                            }
                            if (addr.address is Inet4Address) {
                                LogUtils.d("ipv4", addr.address.hostAddress)
                                ipv4 = addr.address.hostAddress as String
                                continue
                            }
                        }
                    }
                    override fun onCapabilitiesChanged(
                        network: Network,
                        networkCapabilities: NetworkCapabilities
                    ) {
                        super.onCapabilitiesChanged(network, networkCapabilities)
                        try {
                            val wifiInfo = networkCapabilities.transportInfo as WifiInfo
                            if (wifiInfo.bssid != "02:00:00:00:00:00"){
                                mac = wifiInfo.bssid
                            }
                            if (wifiInfo.ssid != "<unknown ssid>") {
//                                ssid = wifiInfo.ssid
                            }
                        } catch (e: Exception) {
                            LogUtils.e(e)
                        }
                    }

                    override fun onLost(network: Network) {
//                        ssid = ""
                        mac = ""
                        super.onLost(network)
                    }

                    override fun onUnavailable() {
//                        ssid = ""
                        mac = ""
                        super.onUnavailable()
                    }
                }
                connMgr.registerNetworkCallback(request, obj)
            }
            else -> {
                val wifiManager = context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
                val net = wifiManager.connectionInfo
//                ssid = net.ssid?: ""
                mac = net.bssid?: ""
                refreshIp()
            }
        }
    }

    init {
        initNetwork()
    }
}


签名、加密与keystore相关


获取签名：

import android.content.Context
import android.content.pm.PackageInfo
import android.content.pm.PackageManager
import android.content.pm.Signature
import android.util.Log
import java.security.MessageDigest
import java.util.Locale

/**
 * 获取签名工具类
 */
object AppSigning {
    val MD5 = "MD5"
    val SHA1 = "SHA1"
    val SHA256 = "SHA256"
    private val mSignMap = HashMap<String, ArrayList<String>?>()

    /**
     * 返回一个签名的对应类型的字符串
     *
     * @param context
     * @param type
     * @return 因为一个安装包可以被多个签名文件签名，所以返回一个签名信息的list
     */
    fun getSignInfo(context: Context?, type: String?): ArrayList<String>? {
        if (context == null || type == null) {
            return null
        }
        val packageName = context.packageName ?: return null
        if (mSignMap[type] != null) {
            return mSignMap[type]
        }
        val mList = ArrayList<String>()
        try {
            val signs = getSignatures(context, packageName)
            for (sig: Signature in signs!!) {
                var tmp = "error!"
                if (MD5 == type) {
                    tmp = getSignatureByteString(sig, MD5)
                } else if (SHA1 == type) {
                    tmp = getSignatureByteString(sig, SHA1)
                } else if (SHA256 == type) {
                    tmp = getSignatureByteString(sig, SHA256)
                }
                mList.add(tmp)
            }
        } catch (e: Exception) {
            Log.e("e", e.message!!)
        }
        mSignMap[type] = mList
        return mList
    }

    /**
     * 获取签名sha1值
     *
     * @param context
     * @return
     */
    fun getSha1(context: Context?): String {
        var res = ""
        val mlist = getSignInfo(context, SHA1)
        if (mlist != null && mlist.size != 0) {
            res = mlist[0]
        }
        return res
    }

    /**
     * 获取签名MD5值
     *
     * @param context
     * @return
     */
    fun getMD5(context: Context?): String {
        var res = ""
        val mlist = getSignInfo(context, MD5)
        if (mlist != null && mlist.size != 0) {
            res = mlist[0]
        }
        return res
    }

    /**
     * 获取签名SHA256值
     *
     * @param context
     * @return
     */
    fun getSHA256(context: Context?): String {
        var res = ""
        val mlist = getSignInfo(context, SHA256)
        if (mlist != null && mlist.size != 0) {
            res = mlist[0]
        }
        return res
    }

    /**
     * 返回对应包的签名信息
     *
     * @param context
     * @param packageName
     * @return
     */
    private fun getSignatures(context: Context, packageName: String): Array<Signature>? {
        var packageInfo: PackageInfo? = null
        try {
            packageInfo =
                context.packageManager.getPackageInfo(packageName, PackageManager.GET_SIGNATURES)
            return packageInfo.signatures
        } catch (e: Exception) {
            Log.e("e", e.toString())
        }
        return null
    }

    /**
     * 获取相应的类型的字符串（把签名的byte[]信息转换成16进制）
     *
     * @param sig
     * @param type
     * @return
     */
    private fun getSignatureString(sig: Signature, type: String): String {
        val hexBytes = sig.toByteArray()
        var fingerprint = "error!"
        try {
            val digest = MessageDigest.getInstance(type)
            if (digest != null) {
                val digestBytes = digest.digest(hexBytes)
                val sb = StringBuilder()
                for (digestByte: Byte in digestBytes) {
                    sb.append(
                        Integer.toHexString(digestByte.toInt() and 0xFF or 0x100)
                            .substring(1, 3)
                    )
                }
                fingerprint = sb.toString()
            }
        } catch (e: Exception) {
            Log.e("e", e.toString())
        }
        return fingerprint
    }

    /**
     * 获取相应的类型的字符串（把签名的byte[]信息转换成 95:F4:D4:FG 这样的字符串形式）
     *
     * @param sig
     * @param type
     * @return
     */
    private fun getSignatureByteString(sig: Signature, type: String): String {
        val hexBytes = sig.toByteArray()
        var fingerprint = "error!"
        try {
            val digest = MessageDigest.getInstance(type)
            if (digest != null) {
                val digestBytes = digest.digest(hexBytes)
                val sb = StringBuilder()
                for (digestByte: Byte in digestBytes) {
                    sb.append(
                        Integer.toHexString(digestByte.toInt() and 0xFF or 0x100)
                            .substring(1, 3).uppercase(Locale.getDefault())
                    )
                    sb.append(":")
                }
                fingerprint = sb.substring(0, sb.length - 1).toString()
            }
        } catch (e: Exception) {
            Log.e("e", e.toString())
        }
        return fingerprint
    }
}



加解密：

import java.io.IOException
import java.nio.charset.Charset
import java.security.*
import java.security.cert.CertificateException
import javax.crypto.*
import javax.crypto.spec.GCMParameterSpec
/**
 * 解密
 */
class Decrypt {
    private val TRANSFORMATION = "AES/GCM/NoPadding"
    private val ANDROID_KEY_STORE = "AndroidKeyStore"

    private var keyStore: KeyStore? = null

    init {
        initKeyStore()
    }

    @Throws(
        KeyStoreException::class,
        CertificateException::class,
        NoSuchAlgorithmException::class,
        IOException::class
    )
    private fun initKeyStore() {
        keyStore = KeyStore.getInstance(ANDROID_KEY_STORE).apply {
            load(null)
        }
    }

    @Throws(
        UnrecoverableEntryException::class,
        NoSuchAlgorithmException::class,
        KeyStoreException::class,
        NoSuchProviderException::class,
        NoSuchPaddingException::class,
        InvalidKeyException::class,
        IOException::class,
        BadPaddingException::class,
        IllegalBlockSizeException::class,
        InvalidAlgorithmParameterException::class
    )
    fun decryptData(alias: String, encryptedData: ByteArray?, encryptionIv: ByteArray?): String {
        val cipher: Cipher = Cipher.getInstance(TRANSFORMATION)
        val spec = GCMParameterSpec(128, encryptionIv)
        cipher.init(Cipher.DECRYPT_MODE, getSecretKey(alias), spec)
        return String(cipher.doFinal(encryptedData), Charset.forName("UTF-8"))
    }

    @Throws(
        NoSuchAlgorithmException::class,
        UnrecoverableEntryException::class,
        KeyStoreException::class
    )
    private fun getSecretKey(alias: String): SecretKey? {
        return (keyStore!!.getEntry(alias, null) as KeyStore.SecretKeyEntry).secretKey
    }
}

import android.security.keystore.KeyGenParameterSpec
import android.security.keystore.KeyProperties
import androidx.annotation.NonNull
import java.io.IOException
import java.security.*
import javax.crypto.*

data class EncryptIndex(
    val encryption: ByteArray,
    val vi: ByteArray
)

/**
 * 加密
 */
class Encrypt {
    private val TRANSFORMATION = "AES/GCM/NoPadding"
    private val ANDROID_KEY_STORE = "AndroidKeyStore"

    private lateinit var iv: ByteArray

    @Throws(
        UnrecoverableEntryException::class,
        NoSuchAlgorithmException::class,
        KeyStoreException::class,
        NoSuchProviderException::class,
        NoSuchPaddingException::class,
        InvalidKeyException::class,
        IOException::class,
        InvalidAlgorithmParameterException::class,
        SignatureException::class,
        BadPaddingException::class,
        IllegalBlockSizeException::class
    )
    fun encryptText(alias: String, textToEncrypt: String): EncryptIndex {
        val cipher: Cipher = Cipher.getInstance(TRANSFORMATION)
        cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(alias))
        return EncryptIndex(cipher.doFinal(textToEncrypt.toByteArray(charset("UTF-8"))), cipher.iv)
    }

    @NonNull
    @Throws(
        NoSuchAlgorithmException::class,
        NoSuchProviderException::class,
        InvalidAlgorithmParameterException::class
    )
    private fun getSecretKey(alias: String): SecretKey? {
        val keyGenerator: KeyGenerator = KeyGenerator
            .getInstance(KeyProperties.KEY_ALGORITHM_AES, ANDROID_KEY_STORE)
        keyGenerator.init(
            KeyGenParameterSpec.Builder(
                alias,
                KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
            )
                .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
                .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
                .build()
        )
        return keyGenerator.generateKey()
    }

    fun getIv(): ByteArray {
        return iv
    }
}


keystore数据存储

class KeyStoreUtil(val context: ReactContext) {
    private val encrypt = Encrypt()
    private val decrypt = Decrypt()
    val kDfpSharedPreference = SharePreferencesBuilder().build(context, "security")
    val cerfPfxSharedPreferences = SharePreferencesBuilder().build(context, "pfx")
    private var pfxKeyStore: KeyStore? = null


    fun getPfxKeyStore(pfx: ByteArrayInputStream, pwd: String): KeyStore? {
        if (pfxKeyStore != null)
            return pfxKeyStore
        pfxKeyStore = KeyStore.getInstance("PKCS12")
        pfxKeyStore!!.load(pfx, pwd.toCharArray())
        return pfxKeyStore
    }

    fun decodeData(user: String, data: String, iv: String): String {
        val decodeData: ByteArray = Base64.decode(data, Base64.DEFAULT)
        val decodeIv: ByteArray = Base64.decode(iv, Base64.DEFAULT)
        return decryptData(user, decodeData, decodeIv)
    }

    fun getAssertIndex(user: String): NativeAsset? {
        val data = cerfPfxSharedPreferences.getString(user)
        val iv = cerfPfxSharedPreferences.getString(user + "iv")
        val index = decodeData(user, data, iv)
        return Gson().fromJson(index, NativeAsset::class.java)
    }

    fun getPfxCertWithHttp(user: String): OkHttpClient {
        val assetModel = getAssertIndex(user)
        val pfxByte = Base64.decode(assetModel?.pfx, Base64.DEFAULT)
        val pfx = pfxByte.inputStream()
        val pwd = assetModel?.password
        val sslParams = TrustManagerUtil.getSslSocketFactory(pfx, pwd, context, user)
        return OkHttpClient.Builder()
            .sslSocketFactory(sslParams.sSLSocketFactory, sslParams.trustManager)
            .hostnameVerifier{ _, _ -> true}
            .build()
    }

    fun getPfxSn(user: String): String? {
        return try {
            val data = cerfPfxSharedPreferences.getString(user)
            val iv = cerfPfxSharedPreferences.getString(user + "iv")
            val index = decodeData(user, data, iv)
            val assetModel = Gson().fromJson(index, NativeAsset::class.java)
            val pfx = Base64.decode(assetModel.pfx, Base64.DEFAULT).inputStream()
            val sn = getPfxSn(pfx, assetModel.password).apply {
                LogUtils.d("pfx sn:", this)
            }
            sn
        }catch (e: Exception) {
            e.printStackTrace()
            e.message
        }
    }

    fun getCert(user: String): X509Certificate? {
        return try {
            val data = cerfPfxSharedPreferences.getString(user)
            val iv = cerfPfxSharedPreferences.getString(user + "iv")
            val index = decodeData(user, data, iv)
            val assetModel = Gson().fromJson(index, NativeAsset::class.java)
            val pfx = Base64.decode(assetModel.pfx, Base64.DEFAULT).inputStream()
            getX509Certificate(pfx, assetModel.password)!!.cert
        }catch (e: Exception) {
            e.printStackTrace()
            e.message
            null
        }
    }

    data class CertData(
        val cert: X509Certificate,
        val privateKey: PrivateKey,
        var caList: ArrayList<X509Certificate> = ArrayList()
    )
    // pfx证书
    fun getX509Certificate(pfx: ByteArrayInputStream, pwd: String): CertData? {
        val pfxKeyStore = getPfxKeyStore(pfx, pwd)
        val aliases: Enumeration<String> = pfxKeyStore!!.aliases()
        var x509Certificate: X509Certificate? = null
        var privateKey: PrivateKey? = null
        aliases.iterator().forEach {
            if (pfxKeyStore.isKeyEntry(it)) {
                try {
                   privateKey = pfxKeyStore.getKey(it, pwd.toCharArray()) as PrivateKey
                   x509Certificate = pfxKeyStore.getCertificate(it) as X509Certificate
                }catch (e: Exception){
                    LogUtils.e("load x509 fail", e)
                }
            }
        }
        return x509Certificate?.let { privateKey?.let { it1 -> CertData(it, it1) } }
    }

    // 获取证书序列号
    fun getPfxSn(pfx: ByteArrayInputStream, pwd: String): String? {
        return try {
            val cert = getX509Certificate(pfx, pwd)!!.cert
            val serialNumber = cert.serialNumber
            serialNumber.toString()
        }catch (e: Exception) {
            e.printStackTrace()
            null
        }
    }

    fun deleteCert(alias: String) {
        try {
            val aliases = pfxKeyStore!!.aliases();
            aliases.iterator().forEach {
                if (pfxKeyStore!!.isKeyEntry(it)) {
                    pfxKeyStore?.deleteEntry(alias)
                }
            }
        }catch (e: Exception) {
            e.printStackTrace()
        }
    }

    // 加密
    fun encryptData(alias: String, data: String): EncryptIndex? {
        return try {
            encrypt.encryptText(alias, data)
        } catch (e: Exception) {
            e.printStackTrace()
            LogUtils.e(e.message)
            null
        }
    }

    // 解密
    private fun decryptData(alias: String, data: ByteArray, iv: ByteArray): String {
        return decrypt.decryptData(alias, data, iv)
    }

}


http自定义信任管理

import android.annotation.SuppressLint
import com.facebook.react.bridge.ReactContext
import java.io.IOException
import java.io.InputStream
import java.security.KeyStore
import java.security.KeyStoreException
import java.security.NoSuchAlgorithmException
import java.security.cert.CertificateException
import java.security.cert.X509Certificate
import javax.net.ssl.*

class TrustManagerUtil {
    class SSLParams {
        lateinit var sSLSocketFactory: SSLSocketFactory
        lateinit var trustManager: X509TrustManager
    }

    private class UnSafeTrustManager : X509TrustManager {
        @SuppressLint("TrustAllX509TrustManager")
        @Throws(CertificateException::class)
        override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) {
        }

        @SuppressLint("TrustAllX509TrustManager")
        @Throws(CertificateException::class)
        override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) {
        }

        override fun getAcceptedIssuers(): Array<X509Certificate> {
            return arrayOf()
        }
    }


    private class MyTrustManager @Throws(NoSuchAlgorithmException::class, KeyStoreException::class)
    constructor(private val localTrustManager: X509TrustManager) : X509TrustManager {
        private val defaultTrustManager: X509TrustManager?

        init {
            val var4 = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
            var4.init(null as KeyStore?)
            defaultTrustManager = chooseTrustManager(var4.trustManagers)
        }


        @SuppressLint("TrustAllX509TrustManager")
        @Throws(CertificateException::class)
        override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) {

        }

        @Throws(CertificateException::class)
        override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) {
            try {
                defaultTrustManager!!.checkServerTrusted(chain, authType)
            } catch (ce: CertificateException) {
                localTrustManager.checkServerTrusted(chain, authType)
            }
        }

        override fun getAcceptedIssuers(): Array<X509Certificate> {
            return arrayOf()
        }
    }

    companion object {

        fun getSslSocketFactory(certificates: InputStream, password: String?, context: ReactContext, alias: String): SSLParams {
            val sslParams = SSLParams()
            try {
                val trustManagers = prepareTrustManager(certificates, context, alias)
                val keyManagers = prepareKeyManager(certificates, password)
                val sslContext = SSLContext.getInstance("TLS")
                var trustManager: X509TrustManager = UnSafeTrustManager()

                trustManagers?.let { arrayOfTrustManagers ->
                    val x509TrustManager = chooseTrustManager(arrayOfTrustManagers)
                    x509TrustManager?.let { trustManager = MyTrustManager(it) }
                }

                sslContext.init(keyManagers, arrayOf<TrustManager>(trustManager), null)
                sslParams.sSLSocketFactory = sslContext.socketFactory
                sslParams.trustManager = trustManager
                return sslParams
            } catch (e: Exception) {
                throw AssertionError(e)
            }
        }

        private fun prepareTrustManager(certificate: InputStream, context: ReactContext, alias: String): Array<TrustManager>? {
            if (certificate == null) return null
            try {
                val keyStore = KeyStore.getInstance("PKCS12")
                keyStore.load(null)
                val cert = KeyStoreUtil(context).getCert(alias)
                keyStore.setCertificateEntry(alias, cert)
                try {
                    certificate.close()
                } catch (e: IOException) { }

                val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
                trustManagerFactory.init(keyStore)

                return trustManagerFactory.trustManagers
            } catch (e: Exception) {
                e.printStackTrace()
            }

            return null
        }

        private fun prepareKeyManager(bksFile: InputStream?, password: String?): Array<KeyManager>? {
            try {
                if (bksFile == null || password == null) return null

                val clientKeyStore = KeyStore.getInstance("PKCS12")
                clientKeyStore.load(bksFile, password.toCharArray())
                val keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm())
                keyManagerFactory.init(clientKeyStore, password.toCharArray())
                return keyManagerFactory.keyManagers

            } catch (e: java.lang.Exception) {
                e.printStackTrace()
            }
            return null
        }

        private fun chooseTrustManager(trustManagers: Array<TrustManager>): X509TrustManager? {
            for (trustManager in trustManagers) {
                if (trustManager is X509TrustManager) {
                    return trustManager
                }
            }
            return null
        }
    }
}

]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/36
            https://umb.ink/post/36
            Fri, 24 Jan 2025 10:43:08 GMT
            整理一下之前工作中用到的GRPC相关内容

]]>
            
      
      
      
      
整理一下之前工作中用到的GRPC相关内容

grpc定义
grpc是一种接口描述协议，我们可以通过定义proto文件来自动实现相关代码逻辑，举个例子：
"proto3";

// 标记所属包名
package grpc_test;
// 标记生成的go代码目录：即生成代码后会把代码文件丢到当前目录下的grpc_test文件夹中（如果是java-grpc，则是java_package)
option go_package = "./grpc_test";

// 可以把这个messsage理解为结构体定义，这个message映射为代码类或实体结构体，这里的=1和=2是在标记这个字段，从1开始，第几个字段标记为几
message GrpcHelloWorldReq {
    string message = 1;
    // 可以定义string list
    repeated string messageList = 2;
}

message GrpcHelloWorldResp {
    string message = 1;
    // 可以定义结构体list
    repeated GrpcHelloWorldReq req = 2;
}

service MeetingDeviceService {
    rpc HelloWorld(GrpcHelloWorldReq) returns (GrpcHelloWorldResp){}
    // 定义一个rpc接口，输入GrpcHelloWorldReq结构体，返回GrpcHelloWorldResp
}


代码生成
在proto文件目录下运行下面的指令
package main

import (
	"context"
	"fmt"
	"net"

	"kafka-test/main/grpc_test"

	"google.golang.org/grpc"
)

type server struct {
	grpc_test.MeetingDeviceServiceServer
}

func (s *server) HelloWorld(ctx context.Context, req *grpc_test.GrpcHelloWorldReq) (*grpc_test.GrpcHelloWorldResp, error) {
	fmt.Println("request:", req.Message)
	return &grpc_test.GrpcHelloWorldResp{Message: "hello " + req.Message}, nil
}

func main() {
	listen, err := net.Listen("tcp", ":8001")
	if err != nil {
		fmt.Printf("failed to listen: %v", err)
		return
	}
	s := grpc.NewServer()
	//reflection.Register(s)

	defer func() {
		s.Stop()
		listen.Close()
	}()

	fmt.Println("Serving 8001...")
	err = s.Serve(listen)
	if err != nil {
		fmt.Printf("failed to serve: %v", err)
		return
	}
}

客户端：
package main

import (
	"context"
	"fmt"
	"sync"

	"kafka-test/main/grpc_test"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

var (
	meetingRoomRpcClient grpc_test.MeetingDeviceServiceClient
	once                 = sync.Once{}
)

func init() {
	var serviceHost = "127.0.0.1:8001"

	conn, err := grpc.Dial(serviceHost, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		fmt.Println(err)
	}
	defer conn.Close()
	// 初始化client（这里client作为调用方，所以只需要初始化一次）
	once.Do(func() {
		meetingRoomRpcClient = grpc_test.NewMeetingDeviceServiceClient(conn)
		//meetingRoomRpcClient = grpc_test.NewMeetingDeviceServiceClient("meeting-device-service")
	})

}

func RpcHellWorld() {
	worldResp, err := meetingRoomRpcClient.HelloWorld(context.Background(), &grpc_test.GrpcHelloWorldReq{
		Message:     "hello world",
		MessageList: []string{"hello world", "hello world"},
	})
	if err != nil {
		return
	}
	fmt.Println(worldResp.Message)
}

启动服务后，rpc服务会运行在本地的8001端口，因此作为下游客户端的rpc服务只需要监听这个8001端口即可实现rpc调用。当然，下游的rpc客户端服务也可以定义自己的proto rpc文件，然后被其他服务调用自己的rpc方法。
在rpc服务调用过程中，谁提供方法接口，谁是server，谁调用方法接口，谁是client，只是一个相对概念。
进阶——服务发现ETCD
当RPC服务多了以后，我们需要配置每个RPC服务的IP和端口，非常麻烦，因此这就需要用到注册中心来简化RPC服务管理。用注册中心的话，我们只需要记住每个服务的服务名即可，就不用再挨个记IP了。
放一个官方文档：https://etcd.io/docs/v3.5/quickstart/

安装请自行参考官方文档
ETCD注册服务端：
import (
	"context"
	"flag"
	"fmt"
	"net"
	"time"

	grpc_test2 "kafka-test/rpc/grpc_test"

	// etcd
	eclient "go.etcd.io/etcd/client/v3"
	"go.etcd.io/etcd/client/v3/naming/endpoints"
	"google.golang.org/grpc"
)

const (
	// grpc 服务名
	GrpcTestServiceName = "umb/grpc-test"
	// etcd 端口
	ETCD_ADDR = "http://localhost:2379"
)

type server struct {
	grpc_test2.UnimplementedGrpcHelloWorldServiceServer
}

func (s *server) HelloWorld(ctx context.Context, req *grpc_test2.GrpcHelloWorldReq) (*grpc_test2.GrpcHelloWorldResp, error) {
	fmt.Println("request:", req.Message)
	return &grpc_test2.GrpcHelloWorldResp{Message: "hello " + req.Message}, nil
}

func registerEndPointToEtcd(ctx context.Context, addr string) {
	// 创建 etcd 客户端
	etcdClient, _ := eclient.NewFromURL(ETCD_ADDR)
	etcdManager, _ := endpoints.NewManager(etcdClient, GrpcTestServiceName)

	// 创建一个租约，每隔 10s 需要向 etcd 汇报一次心跳，证明当前节点仍然存活
	var ttl int64 = 10
	lease, _ := etcdClient.Grant(ctx, ttl)

	// 添加注册节点到 etcd 中，并且携带上租约 id
	_ = etcdManager.AddEndpoint(ctx, fmt.Sprintf("%s/%s", GrpcTestServiceName, addr), endpoints.Endpoint{Addr: addr}, eclient.WithLease(lease.ID))

	// 每隔 5 s进行一次延续租约的动作
	for {
		select {
		case <-time.After(5 * time.Second):
			// 续约操作
			resp, _ := etcdClient.KeepAliveOnce(ctx, lease.ID)
			fmt.Printf("keep alive resp: %+v", resp)
		case <-ctx.Done():
			return
		}
	}
}

func InitRpcServer() {
	var port int
	flag.IntVar(&port, "port", 8001, "port")
	flag.Parse()
	addr := fmt.Sprintf("http://localhost:%d", port)
	listen, err := net.Listen("tcp", addr)
	if err != nil {
		fmt.Printf("failed to listen: %v", err)
		return
	}
	s := grpc.NewServer()
	//reflection.Register(s)
	grpc_test2.RegisterGrpcHelloWorldServiceServer(s, &server{})
	defer func() {
		s.Stop()
		listen.Close()
	}()
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	// 注册 grpc 服务节点到 etcd 中
	go registerEndPointToEtcd(ctx, addr)
	fmt.Println("Serving 8001...")
	err = s.Serve(listen)
	if err != nil {
		fmt.Printf("failed to serve: %v", err)
		return
	}
}

ETCD注册客户端：
import (
	"context"
	"fmt"
	"sync"

	grpc_test2 "kafka-test/rpc/grpc_test"

	// etcd
	eclient "go.etcd.io/etcd/client/v3"
	eresolver "go.etcd.io/etcd/client/v3/naming/resolver"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

var (
	meetingRoomRpcClient grpc_test2.GrpcHelloWorldServiceClient
	once                 = sync.Once{}
)

func init() {
	// 创建 etcd 客户端
	etcdClient, _ := eclient.NewFromURL(ETCD_ADDR)

	// 创建 etcd 实现的 grpc 服务注册发现模块 resolver
	etcdResolverBuilder, _ := eresolver.NewBuilder(etcdClient)

	// 拼接服务名称，需要固定义 etcd:/// 作为前缀
	etcdTarget := fmt.Sprintf("etcd:///%s", GrpcTestServiceName)

	// 创建 grpc 连接代理
	conn, _ := grpc.Dial(
		// 服务名称
		etcdTarget,
		// 注入 etcd resolver
		grpc.WithResolvers(etcdResolverBuilder),
		// 声明使用的负载均衡策略为 roundrobin     grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, roundrobin.Name)),
		grpc.WithTransportCredentials(insecure.NewCredentials()),
	)
	defer conn.Close()
	defer conn.Close()
	// 初始化client（这里client作为调用方，所以只需要初始化一次）
	once.Do(func() {
		meetingRoomRpcClient = grpc_test2.NewGrpcHelloWorldServiceClient(conn)
		//meetingRoomRpcClient = grpc_test.NewMeetingDeviceServiceClient("meeting-device-service")
	})

}

func RpcHellWorld() {
	worldResp, err := meetingRoomRpcClient.HelloWorld(context.Background(), &grpc_test2.GrpcHelloWorldReq{
		Message:     "hello world",
		MessageList: []string{"hello world", "hello world"},
	})
	if err != nil {
		return
	}
	fmt.Println(worldResp.Message)
}

这样基于ETCD改造之后，server和客户端只需要知道对方的名称就能用了
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/34
            https://umb.ink/post/34
            Fri, 24 Jan 2025 10:38:18 GMT
            
      
      
      
      
前置准备
安装kafka-sarama库
直接附带我的go mod：
.45.0
	github.com/xdg/scram v1.0.5
	go.uber.org/zap v1.27.0
)

require (
	github.com/davecgh/go-spew v1.1.1 // indirect
	github.com/eapache/go-resiliency v1.7.0 // indirect
	github.com/eapache/go-xerial-snappy v0.0.0-20230731223053-c322873962e3 // indirect
	github.com/eapache/queue v1.1.0 // indirect
	github.com/golang/snappy v0.0.4 // indirect
	github.com/hashicorp/errwrap v1.1.0 // indirect
	github.com/hashicorp/go-multierror v1.1.1 // indirect
	github.com/hashicorp/go-uuid v1.0.3 // indirect
	github.com/jcmturner/aescts/v2 v2.0.0 // indirect
	github.com/jcmturner/dnsutils/v2 v2.0.0 // indirect
	github.com/jcmturner/gofork v1.7.6 // indirect
	github.com/jcmturner/gokrb5/v8 v8.4.4 // indirect
	github.com/jcmturner/rpc/v2 v2.0.3 // indirect
	github.com/klauspost/compress v1.17.11 // indirect
	github.com/pierrec/lz4/v4 v4.1.22 // indirect
	github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect
	github.com/xdg/stringprep v1.0.3 // indirect
	go.uber.org/multierr v1.10.0 // indirect
	golang.org/x/crypto v0.32.0 // indirect
	golang.org/x/net v0.34.0 // indirect
	golang.org/x/text v0.21.0 // indirect
)


XDGSCRAM 解密
import (
	"crypto/sha256"
	"crypto/sha512"

	"github.com/xdg/scram"
)

var (
	// SHA256 ...
	SHA256 scram.HashGeneratorFcn = sha256.New
	// SHA512 ...
	SHA512 scram.HashGeneratorFcn = sha512.New
)

// XDGSCRAMClient ...
type XDGSCRAMClient struct {
	*scram.Client
	*scram.ClientConversation
	scram.HashGeneratorFcn
}

// Begin ...
func (x *XDGSCRAMClient) Begin(userName, password, authzID string) (err error) {
	x.Client, err = x.HashGeneratorFcn.NewClient(userName, password, authzID)
	if err != nil {
		return err
	}
	x.ClientConversation = x.Client.NewConversation()
	return nil
}

// Step ...
func (x *XDGSCRAMClient) Step(challenge string) (response string, err error) {
	response, err = x.ClientConversation.Step(challenge)
	return
}

// Done ...
func (x *XDGSCRAMClient) Done() bool {
	return x.ClientConversation.Done()
}


消费者接入：
package main

import (
	"context"
	"log"
	"os"
	"os/signal"
	"sync"
	"syscall"

	"github.com/IBM/sarama"
)

type Kafka struct {
	brokers           []string
	topics            []string
	startOffset       int64
	version           string
	ready             chan bool
	group             string
	channelBufferSize int
	assignor          string
}

var assignor = "range"
var topics = []string{"your_topic"} // topic
var group = "consumer_group" // 订阅消费组
var user = "user" // sarma用户
var password = "pwd"  // sarama 密码
var brokers = []string{"127.0.0.1:6279"} // 你的kafka host

func NewKafka() *Kafka {
	return &Kafka{
		brokers:           brokers,
		topics:            topics,
		group:             group,
		channelBufferSize: 1000,
		ready:             make(chan bool),
		assignor:          assignor,
	}
}

func (k *Kafka) Connect() func() {
	log.Println("kafka init...")
	config := sarama.NewConfig()
	config.Version = sarama.V2_4_1_0 // 版本号必须注意要同步，否则会报错
	// 分区分配策略
	switch assignor {
	case "sticky":
		config.Consumer.Group.Rebalance.Strategy = sarama.BalanceStrategySticky
	case "roundrobin":
		config.Consumer.Group.Rebalance.Strategy = sarama.BalanceStrategyRoundRobin
	case "range":
		config.Consumer.Group.Rebalance.Strategy = sarama.BalanceStrategyRange
	default:
		log.Panicf("Unrecognized consumer group partition assignor: %s", assignor)
	}
	config.Consumer.Offsets.Initial = sarama.OffsetNewest
	config.ChannelBufferSize = k.channelBufferSize // channel长度
	config.Consumer.Offsets.Initial = sarama.OffsetOldest
	config.Consumer.Group.Rebalance.Strategy = sarama.BalanceStrategyRoundRobin
	config.Net.SASL.Enable = true
	config.Net.SASL.User = user
	config.Net.SASL.Password = password
	config.Net.SASL.Handshake = true
	config.Net.SASL.SCRAMClientGeneratorFunc = func() sarama.SCRAMClient {
		return &XDGSCRAMClient{HashGeneratorFcn: SHA256}
	}
	config.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA256
	// 创建client
	log.Println("brokers: ", brokers)
	newClient, err := sarama.NewClient(brokers, config)
	if err != nil {
		log.Fatalf("Error creating client: %v", err)
	}
	// 获取所有的topic
	topics, err := newClient.Topics()
	if err != nil {
		log.Fatal(err)
	}
	log.Println("topics: ", topics)

	// 根据client创建consumerGroup
	client, err := sarama.NewConsumerGroupFromClient(k.group, newClient)
	if err != nil {
		log.Fatalf("Error creating consumer group client: %v", err)
	}

	ctx, cancel := context.WithCancel(context.Background())
	wg := &sync.WaitGroup{}
	wg.Add(1)
	go func() {
		defer wg.Done()
		for {
			if err := client.Consume(ctx, k.topics, k); err != nil {
				// 当setup失败的时候，error会返回到这里
				log.Println("Error from consumer: %v", err)
				return
			}
			// check if context was cancelled, signaling that the consumer should stop
			if ctx.Err() != nil {
				log.Println(ctx.Err())
				return
			}
			k.ready = make(chan bool)
		}
	}()
	<-k.ready
	log.Println("Sarama consumer up and running!...")
	// 保证在系统退出时，通道里面的消息被消费
	return func() {
		log.Println("kafka close")
		cancel()
		wg.Wait()
		if err = client.Close(); err != nil {
			log.Println("Error closing client: %v", err)
		}
	}
}

// Setup is run at the beginning of a new session, before ConsumeClaim
func (k *Kafka) Setup(session sarama.ConsumerGroupSession) error {
	log.Println("setup")
	session.ResetOffset("lvmi", 0, 13, "")
	log.Println(session.Claims())
	// Mark the consumer as ready
	close(k.ready)
	return nil
}

// Cleanup is run at the end of a session, once all ConsumeClaim goroutines have exited
func (k *Kafka) Cleanup(sarama.ConsumerGroupSession) error {
	log.Println("cleanup")
	return nil
}

// ConsumeClaim must start a consumer loop of ConsumerGroupClaim's Messages().
func (k *Kafka) ConsumeClaim(session sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error {

	// NOTE:
	// Do not move the code below to a goroutine.
	// The `ConsumeClaim` itself is called within a goroutine, see:
	// https://github.com/Shopify/sarama/blob/master/consumer_group.go#L27-L29
	// 具体消费消息
	for message := range claim.Messages() {
		log.Printf("[topic:%s] [partiton:%d] [offset:%d] [value:%s] [time:%v]",
			message.Topic, message.Partition, message.Offset, string(message.Value), message.Timestamp)
		// 更新位移
		session.MarkMessage(message, "")
	}
	return nil
}

func main() {
	k := NewKafka()
	c := k.Connect()

	sigterm := make(chan os.Signal, 1)
	signal.Notify(sigterm, syscall.SIGINT, syscall.SIGTERM)
	select {
	case <-sigterm:
		log.Println("terminating: via signal")
	}
	c()
}

]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/33
            https://umb.ink/post/33
            Sun, 22 Dec 2024 15:40:19 GMT
            2024-时间线
]]>
            
      
      
      
      
2024-时间线



1月：新年


一月初人在上海，恰好赶上跨年，比较幸运在八角场线下参加了B站的跨年夜活动
当时拍的照片：

在上海和朋友夹了娃娃，非常幸运，夹了一大坨

月末高中的兄弟来北京玩，一起去了颐和园（高糊画质）



2月：过年


难得回家休息，拼了从上海带回来的自由高达：


过年最重要的事情当然是几个街溜子在午夜放烟花

年后陪家人去了古县城（这里真的安利太原古县城）


年后临近返工，获知了一位朋友将要订婚的消息，都非常开心，也是突然发现，原来大家要到谈婚论嫁的年纪了，原来大家已经不再是小孩了。
年后返工，遇上倒春寒，下雪的西二旗



3月：家庭新成员


3月，家庭新加入了新成员——GC，一直两周大的银渐层小猫（非常可爱！！！）
刚到家就往马桶钻的GC：那个时候还很瘦

现在的GC：



4月：樱花


4月小区里的樱花宛如动漫场景，美不胜收，每天出门就是一个享受



5月 晚霞


平平无奇的五月，被某天的晚霞打破了原本的乏味



6月：搬家


被赶出家门，被迫搬家。因为上个房东不愿意出租了，被迫搬离了住了大半年的家，自如赔了点钱，但是还不够补贴差价的=.=。

附一张六月的GC




7月：演唱会！


7月初，临近入职一周年，获得了公司发的奖章！好诶！

7月中，回家呆了几天。突然感觉人都是很脆弱的，可能不觉中某个人就不在了，顿感生命脆弱，也是在这个时候突然发现，我到了要承担家庭重大事项的年纪。
七月末，未来有你——初音未来演唱会！！！
带着曾经实验室的棒子——来自某位热情学弟赞助


非常棒的演唱会企划展：



非常好的法披（狠狠爆了金币）

因为快手买了冠名，所以这次请了蔡萝莉在现场站台cos：

小插曲：
我完成了我的桌搭升级！



8月： 旅游！开发者大会



8月初，抓着月初的簪头，和好兄弟说走就走的周末极限苏州行

拙政园的街道：

七里山塘：

西园寺：


附一张帅气的我好哥们（单身，在线招亲）博主本人长相很一般，且严重社恐，就不献丑了。


还有苏州大裤衩

金鸡湖偶遇的小情侣，这张是我抓拍的，非常有氛围感

凌晨极限跑到了杭州，进行杭州半日游：

西湖旁边的凌晨客栈一角：


看到了雷锋塔


某个周末，在北京王府井看到了高达


8月中：谷歌开发者大会！


世界各地有趣的开发团队：


出发！四川黄龙与九寨沟

公司团队团建，我们来到了黄龙与九寨景区

黄龙：


九寨沟：九寨归来不看水，是真的美



山也很美：

藏民的白塔印象也很深

最后一天去了成都天府红，死宅天堂：



9月：游戏


黑神话8.20上线便引爆了国内游戏圈，趁热九月我也进行了高强度开干。不得不说黑神话悟空真是一件值得被称为艺术品的游戏。

可惜没有那么强的肝，最后也只是通关了三周目，没有做到全成就。




10月：国庆，故地重游，演唱会！！！！


趁着放假，连夜回到了太原，非常好看的太原迎泽大桥，满满的红色浪漫

回到了学校，仅仅一年变得如此气派，震惊了我，差点以为走错了学校。果然是人类定则：毕业后母校马上变样


10月4日，期盼了10年的洛天依演唱会！！！

我从刚上初中那会就喜欢听洛天依的歌，从前尘入梦入坑，被这个纯虚拟的少女歌声吸引，逐渐了解了V家、调教、编程、建模等很多东西，洛天依出现在我的生活中，我也多少受影响才走上了计算机的道路。
第一次在现场，听到上山岗的时候，听哭了。





附近的企划展，也特别好逛（狠狠给禾念爆金币）：




到家后的战利品：


10月20 —— 给学弟学妹分享

实验室之前的学弟学妹在10月中突然邀请我回去给大家分享一些关于大学和就业规划的事情，借着实验室新一批纳新的机会，也比较有幸给大家分享了一些我自己的经历。



11月 总决赛以及加班加班还是加班


11.2是LOL 全球总决赛的日子，公司社团组织了线下观影活动，去现场看了比赛，虽然结果BLG惜败，但依然值得铭记。
依然记得穿着RNG队服去伦敦现场看BLG的哥们



临近年底，团队内追赶项目交付，开始了封闭开发的生活，11月经常连明昼夜地干活，不觉一月就过去了。

12月 加班加班


更临近交付日期了，还是加班。
]]>
            i@umb.ink (伞菌)
            日常
        
        
            
            https://umb.ink/post/umb
            https://umb.ink/post/umb
            Fri, 20 Feb 2026 05:55:45 GMT
            我的2024年度总结
    2024好像过的很快，却又好像过的很慢，懵懵懂懂间，一年又结束了。
    回顾2024年，我的全年关键词是：祛魅。若相比2023年的“变化”，2024年更多的，我见识了形形色色的人与事，感悟到很多东西非我所想，也非我所能，坦然接受，踏步向前，才是人生的基调。
]]>
            
      
      
      
      
我的2024年度总结
    2024好像过的很快，却又好像过的很慢，懵懵懂懂间，一年又结束了。
    回顾2024年，我的全年关键词是：祛魅。若相比2023年的“变化”，2024年更多的，我见识了形形色色的人与事，感悟到很多东西非我所想，也非我所能，坦然接受，踏步向前，才是人生的基调。

为什么是祛魅？
     祛魅，应该算是今年来网络上比较火热的词，对世界祛魅，对职场祛魅。对人生祛魅。意为慢慢消除对一切事物的滤镜，消解美好期待和幻想光环，不去神化、美化一些人或事物，将关注点回到自身。
     回顾我的这一年，经历了很多事情，也见到了很多形形色色的人，发现很多人或事，并没有我想象的的那么美好，也并没有我想象的那么糟糕。
     工作上祛魅，曾经我觉得大厂工作是一件非常自豪的事情，向往大厂的技术氛围，向往大厂的顶级工作环境与先进业务，幻想大厂唯业务技术说话的工作环境。但经历了一年的大厂工作，发现其实大家也都是草台班子，同样会出现的边缘业务，同样会出现的低级故障，同样会出现的人情世故，同样会出现的工作失误，同样会出现的形势误判，同样会出现的吹牛浮夸，浑水摸鱼，终归大家都没有什么不同罢了，终是优秀的人在大厂施展拳脚，而不是大厂促成了优秀的人。

以自我为中心不断进步的人，才是真正的优秀。

     生活上祛魅，过去一年，曾经那个跟着大人上宴席蹭吃蹭喝的我，也到了要作为一个独立的人，出席这些事情的年纪。身边的老人逐渐离去，新人逐渐成婚，逐渐像当年的父母那样，帮衬朋友、上礼的人。小时候跟着大人，只盼着宴席快快上菜，但当轮到自己出席的时候，才深感面对逝者的悲伤，面对新人婚姻的庆贺，面对人生进程加速的无奈。宴席这个在曾经稚嫩的我看来一个可以跟着大人大吃大喝的好事，却变得令我感情复杂。时常会想，如果当轮到我作为宴席的主角，我又能否克制感情，主持好大局？
     感情上祛魅，从小受父母影响，对一份感情，特别是恋爱的感情，非常看重，幻想着，只得一人心，白首不相离，希望有像父母那样纯粹、一眼便是终生的浪漫感情，对爱情这种事情无限幻想着美好。但是经历了身边其他朋友分分合合，见到了各种各样分崩离析的感情，我顿感无力。直到有天无意间看到了付航的脱口秀，“你是你自己剧本的主角”，豁然开朗，再美好的感情，再美好的人，也不能成为某个人生命的主角，我永远作为一个自由的个体，作为自己的主角，任何人的离开，只是结束了这一段剧本，还会有下一段新的剧本等待我的演绎。人生就是一趟永无尽头的旅行，我的列车上会搭载形形色色的人，并与我有一段或深或浅的故事，但终归他们都有到站下车的一天，而我的列车永无止境。所以无论是亲人的离去、挚爱的离去、朋友的离去，无需怀疑自己，也无需遗憾，行好事，问前程，有更加精彩的下一段旅程在等着自己。

“离开的人不要挽留，到来的人不要轻薄”。

     人际交往上祛魅。以前认为高学历、高地位的人总是各方面都远优秀于自己，而没读过什么书，也没有家庭背景的人好像样样不如自己。经常在和高学历背景的朋友交往中有些自卑，但和老家提早进入社会的朋友相比又觉得自己混的还行，有些自负。但随着愈发了解到真实的他们，发现，大家也就都那样。高学历高背景的同样会有抽象的人，离谱的性格，摆烂挂科的废人；提早步入社会，地位较低的劳苦大众也有工作出色，年纪轻轻便在自己的行业发光发热，月入过万，小有所成，甚至有些朋友的现状超过了绝大多数同龄人。终归大家也只是芸芸众生的普通人，只是学历不同、家庭背景不同罢了。在某些特定方面，我自己做的远比高学历高地位的优秀，又在某些地方远不及没读过几年书的人看的透彻，做的更好。人皆平等，没有人是神话，也没有人是完全烂透的人渣。

“大家也就都那样”

     自我祛魅，作为标准的小镇做题家出身，不给别人添麻烦，要多考虑别人，多吃苦才能有出息。类似的语言总在耳边提起，仿佛生来是为了这个世界、为了社会、为了国家、为了家庭、为了他人而活。好像所有的老中普通人一辈子都这样，为了父母而学习，为了公司而工作，为了孩子割舍自己所爱。这样的自我我并不认可，所以今年我随着自己任性了，去了沪苏杭、去了很多次漫展、去了洛天依的演唱会、去了初音未来的演唱会、在有限的时间里做了我想做的事情，我认为这些是真正有意义的事情。

“想做就做，死了就做不成了”

     也在这些事情之后，对很多事情没有了太多的执着，对很多人或事没有了那么深的滤镜，随心而为，很多时候只有自己才是自己的主角，其他人或事，只是自己人生剧本中的一小段插曲。
     因此，我选择了祛魅，作为我这一年的总结。
生活的总结
2024-时间线
工作的总结
今年工作是比较繁杂的，整体压力也相对较大，但总归看着工作上线，也是有所成就感。
因为事情太杂太琐碎，索性直接总结今年在工作中学到的东西与成果好了。
结果

去年做的班车项目，今年加入了基于GPS的自动切换路线迭代了一版本，并且！总乘车人次破一百万啦，看数据的时候感觉非常满足。
今年新做了一个网络可视化的项目，第一次接触到了海量的数据计算，首次学习并使用了Clickhouse进行数据聚合和处理，第一次写程序处理每天千万的数据量，感觉很棒。
相比去年，感觉今年的工作主导性更少，支持性更多，大部分时候都是配合大项目推进，负责其中的一些模块开发，但看着项目如期能够上线，依然有充足感。

感受
累，今年真实感受到了大厂对牛马的压榨与内卷的环境，工作中要处处留心，随时留痕，精力一半在工作上另一半在操心和各种任何事情的处理上，身心俱疲。
来年的愿望

来年希望能去一次日本，去一次洱海。
希望能对工作更得心应手。
希望生活更规律一些，能有精力去运动。
遇到一些更美好的人与事情。
健康的活着。

]]>
            i@umb.ink (伞菌)
            感悟
        
        
            
            https://umb.ink/post/31
            https://umb.ink/post/31
            Fri, 22 Nov 2024 19:13:16 GMT
            起因
之前一直在用腾讯云提供的免费SSL证书，但是从今年年中以来，腾讯云停止了免费签发一年期的SSL证书，而是必须用它给的三个月有效期的证书，非常的恶心人。
因此，转而考虑使用Let's Encrypt签发的免费SSL证书，彻底干掉愚蠢的国内供应商提供的证书。
]]>
            
      
      
      
      
起因
之前一直在用腾讯云提供的免费SSL证书，但是从今年年中以来，腾讯云停止了免费签发一年期的SSL证书，而是必须用它给的三个月有效期的证书，非常的恶心人。
因此，转而考虑使用Let's Encrypt签发的免费SSL证书，彻底干掉愚蠢的国内供应商提供的证书。

配置
在开始之前，请确保你服务器的80端口可以正常访问，并安装了nginx（当然也可以不用nginx，用caddy或者其他的请另寻教程）
另外在你的域名服务提供商那里配置DNS A记录解析到要配置证书的服务器上面
在配置时关闭CDN访问！否则验证会失败！
使用certbot
在你的linux服务器上安装certbot
apt install certbot

配置证书
-d后面跟你的域名即可
 certbot --nginx -d umb.ink

如果遇到Saving debug log to /var/log/letsencrypt/letsencrypt.logThe requested nginx plugin does not appear to be installed的报错，如下图：

则安装python3-certbot-nginx即可，sudo apt install python3-certbot-nginx
完成后继续运行最上面的配置证书指令，按照提示配置你的邮箱、并选择同意

如果遇到Challenge failed for domain 的报错， 检查你的服务器80端口是否可以正常访问！包括但不限于防火墙、端口占用等。


成功配置后：

此时从浏览器外网访问你的域名，就可以看到证书了
配置很简单，并且完全免费，配置只需要几行指令，很省事，是非常好的文明
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/30
            https://umb.ink/post/30
            Mon, 21 Oct 2024 14:30:03 GMT
            前言
这篇文章主要面向初入大学或是正处在人生分界线不知去往何处的同学们，在这里结合了我自己的过去几年的大学经历和工作两年来的一些所见所识，希望用我浅薄的一些感悟，能够给你们一些启发或帮助。

读前说明：这篇文章大部分为我自己的主观感悟，我的经验、经历并不适合所有人，仅在此为读者提供一些思考方向。

]]>
            
      
      
      
      
前言
这篇文章主要面向初入大学或是正处在人生分界线不知去往何处的同学们，在这里结合了我自己的过去几年的大学经历和工作两年来的一些所见所识，希望用我浅薄的一些感悟，能够给你们一些启发或帮助。

读前说明：这篇文章大部分为我自己的主观感悟，我的经验、经历并不适合所有人，仅在此为读者提供一些思考方向。


先说我自己——普通
  写这个篇章主要是想打消部分同学的自卑情绪，希望我的经历能够引起部分人的共鸣，能够让大家带着和我聊天的心情来读这篇文章。如果对我经历没什么兴趣，可以跳过，这里和后面的内容其实没什么关系。
我的经历
大学前
   我不论中考还是高考都只是比较普通的发挥，没有优秀到像火箭班的精英那样，也没有差到去职业中学，在初高中算得上是班里那种不是特别出彩但也不令老师头疼的“普通学生”。家庭也是普通农村移居县城的普通家庭，饿不死但也不算得富裕的典型中国普通农村职工家庭。
大学


高考后，我迎来了自己的第一次抉择，我当时认为，如果此生不能接触我所感兴趣的东西，那我这辈子都将毫无意义。我后来填报志愿，几乎都选了计算机作为第一志愿，也就这样入了我从小心念的计算机门道。


大一来学校前，我偶然了解到我们院系有一个组织叫做“学生实验室”，这个组织主要凝聚了所有对各种计算机技术感兴趣，并且希望在计算机技术上深造的一批同学，类似于社团，但是相比于社团它会有更大的平台资源和学习机会，也会有考核制度。对于在此前从未接触过电脑编程的我，认为实验室都是大佬，我努力加入未来也可以成为像他们一样改变世界的程序员（盲目崇拜感）。


在进入学校前，当时在迎新群里天天水群，听了学长的建议，在入学前找网课自学c语言，并且为加入实验室做准备，在这个期间，还结识了一圈小伙伴一起学习，而这帮小伙伴也成了后来我在实验室的死党们。


进入学校后，我参加了实验室的招新面试，我当时意向动漫创新实验室和安卓实验室（现在我们叫AI+移动互联实验室），这俩应该算得上是当时我们院系综合实力最好的两个实验室了，一个方向是ACG游戏领域，另一个是移动互联开发，最后抉择的时候还是选择加入了安卓，主要因为我和这个实验室学长们接触相对多一些，觉得这个实验室里学长们都好牛逼。



入学不久我就第一次进了医院，因为吃了兰村刁民有问题的麻辣拌，搞得上吐下泻了好久，直接医院，而因为刚入学还没有医保，我硬怼了200的“天价“医药费，上兰帝国理工208块钱一碗的麻辣拌，就此诞生，这个梗在我身边一直传到了我大学毕业。


在加入实验室后，我对自己的大学生活其实没有什么规划，只知道我要先学习技术，至于是考研还是就业，当时我也不知道自己要干啥，对大学生活充满新奇和迷茫，什么都想试试，也想着走一步看一步。

实验室一隅：


第一次获奖，是在第一个学期末，我们院系有一个专门面向大一的程序设计评奖，让大家用c语言做一个游戏出来，比谁的完成度好，可玩性高。然后我当时沉迷碧蓝航线，我就拿c语言做了一个山寨版碧蓝，甚至还做了一点很简单的gal剧情（至于实现的办法全是if else的shi 山罢了），或许是因为比较新奇的游戏构想和那个特殊的Boss战提示“FBI Warning”，让评委们给我评了一个一等奖，有种第一次被充分肯定的感觉，特激动，还准备了好久的发言稿，然后站在了全院面前进行了自己的获奖分享，想来那真的是我大一的全部高光时刻。


转头刚结束颁奖典礼，我就进了医院，连烧三天，住院七天，或许是因为太过兴奋了罢。
我出院半个月后，新冠爆发了。


第一次带队做项目，我们学校有一个创新创业竞赛，规模其实很小，算的上是挑战杯的校赛，当时实验室里面惯例是学长学姐把他们已经拿过国奖的项目给我们这些小屁孩去练手，写写文档跑跑材料什么的。但我当时觉得我可以，我结合家里人是煤矿工人，想了一个方向是做井下安全监测设备的，自己找资料，自己找队员，自己写文档，自己想创新点什么的，全程几乎没有依靠学长学姐的帮助，虽然都是纸上谈兵，但是这个我自己带队，自己主笔的项目一直冲到了校赛决赛。这让我感觉很自豪，虽然整个项目都是我的凭空想象，做不出任何实际的产品，在现在看来甚至可笑，但已经可以很好的交代当时的我自己了。

当时的小盆栽：



第一次国赛，后来在实验室呆了一年多，技术逐渐也上来了，当时的我什么前端、后端、安卓、AI、爬虫、嵌入式开发板都摸着玩了一遍，虽然不算精通但是都算是能撸一个玩意儿出来的水平了。这个时候，刚好到了要准备次年全国计算机设计大赛的时候了。

当时因为我喜欢撸QQ机器人，我自己做了一个群内问答机器人和非法消息监测机器人，主要给迎新群做一些新生问答和各种诈骗消息监测的,并且好评还不错，甚至好多其他院的招新办闻讯来找我希望把bot借给他们用的。
最后在全国计算机设计大赛选题上，我就想基于我已经做过的Bot，去把互联网不实消息的检测做成一个大的开放平台，去给其他人用，关于这个项目可以看我当时的文章以及代码仓库，做的很烂，但私以为对当时的我来说已经能够交代自己。
前后这个项目大概做了六个月左右，这个期间学了docker部署、学了SVM模型、词缀树算法什么的，最后项目也是很幸运地闯进了决赛，我们项目小组只有三个人，一个UI一个前端一个后端+算法，我后端算法一把梭，也因此学到了不少东西。依然记得最后交稿前我们通宵写PPT和文档，赶工项目，一晚上没有睡觉，第二天睡醒接着准备，赶在截止前完成了交稿。
最后嘛，国赛没有拿到我期望的结果，答辩的时候感受到了评委的压力，被问懵了，最后只拿到了国三的成绩，当时感觉有点失落，感觉自己付出了很多努力，甚至觉得自己做的东西还不错，但最后结果却不太如人意，但我觉得那段时间我是充实的，不论是在这个过程学习，还是和大家一起熬夜，都没有觉得有多么累。



后来毕业的时候留存下来自己的一堆证书：


第一次做实验室负责人，或许是我在实验室的活跃，也或许是我和两个死党的“三人帮组合”，让实验室导师们和学长学姐们将实验室22年度负责人的接力棒交给了我。并且刚好正值实验室成立十周年这个很特别的年度，接过接力棒后，“三人帮”做了实验室十周年庆，到处跑资源，给实验室争取来了自实验室这个组织成立以来的最大一笔经费，给实验室置办了巨量的资源，包括了算力服务器、机柜、3D光固化打印机、全套VR采集设备和无人机等一大堆在当时的我们看来是很奢侈的资源，实验室也在不到半年的时间里换了天地，而且实验室各种培训也如火如荼，总觉得在我们那一年，实验室格外地热闹，令人兴奋。

当时拿出来秀的4090：


三人帮留影：


  第一次做赛区负责人，当实验室负责人和老师们难免接触较多，刚好那年学生科的一位负责计算机设计大赛的老师找上了我希望我帮忙负责山西省的计算机设计大赛的筹备和组织工作，虽然听起来比较高级，但其实更多是苦力活，人员组织、赛事通知和答疑、赛事参会、评委组织、报名组织、赛事评审工作筹划，都得自己做，前后忙碌了半年的样子，累麻了只能说那段时间，但是回过头看那段时间真的对我锻炼很多，各种和人沟通表达的锻炼，工作筹划的锻炼，对我而言都是一次非常难忘的经历。（而且还能吹牛逼，我负责过省级大规模的A类竞赛组织，参赛有四五千人）
实验室的一些奖牌

找工作
  第一次真的迷茫，临近毕业的时候，我意识到我大学一直忽略了一个很重要的点，那就是究竟是考研还是就业的选择，当时身边的人都已经全部无脑准备考研了，虽然询问他们为什么要考研，99%的回答是“大家都考”。我当时陷入了迷茫，不知道自己毕业后该往何处去，担心工作找不到考研又错失机会，又担心考不上研究生更难找工作，我有种既要又要的冲动，啥都想抓，又想考研又想找工作，甚至已经买了书选了学校。后来谈了恋爱，我意识到，我不想考研了，因为我懒，而且我想赚钱（这个时候没有那么多的理想抱负了已经）而且我大学学了很多技术，就是没有钻研科研相关的东西，可以说我的整个大学除了学习和科研以外其他技能点都点了个差不多。
  于是我试着开始投简历，恰逢因为疫情导致经济下行，各个大厂都在暴力裁员，23年秋招哀鸿遍野，简历全部石沉大海，那会我每天的节奏就是睡醒投简历，然后背八股，刷题，然后面试，然后被刷，再投简历，如此仿佛了不知道多少次。那段时间只能用绝望形容，我开始怀疑我四年的努力，怀疑我的能力，怀疑未来的方向，甚至有好多次，已经进入offer评估或者HR面了，最后还是被告知没有HC或者没通过offer审核被挂。最终机缘巧合，来到了我现在工作的组里当实习生，最后实习转正正式入职。
整个招聘历程，我花了一年的时间，前后投递了近一千份简历，面试一百多场，最后手中寥寥几个中小厂offer（没有凡尔赛，当时手里最好的是在那年点击即送的吉利汽车和比亚迪的offer, 笛子高攀不起那是后话）
工作后
  工作后，接触了大量的人和事，第一次发觉山外青山，人外有人，环境对人的影响太大了，在职场中，远有能力超群，智商超群，情商超群的人，也发现职场、社会对能力的要求远不是学校所教的那点皮毛，深感大学学校教的都是什么垃圾，落伍而无用。但好在大学的经历让我能够相对胜任我的工作岗位，虽不出色但也不是特别糟糕。
规划
  与教育时期被迫规划，服从性成长不同，进入大学后，我们是一个独立的人，我们要自己决定自己的未来，要自己独立成长，而做好规范是成长的第一步。
认知
规划的第一步，是改变自己的认知，不论是信息获取方面还是思维方面，社会是复杂的，保持“小镇做题家”的思维逻辑是无法走长远的。
1. 信息获取
  在大学前，绝大部分同学的信息获取来自家庭、老师和课本，但是大学后，不会有人主动告诉你该做什么，要做什么，学校能教授的东西非常有限，甚至可以说是无用，因此不要在大学指望学校能教给你什么有用的东西。我们现在的大学教育和社会所需是完全脱节的，你在学校学到的东西在实际公司的业务场景中可能已经落后十年了。也不要指望大学的老师教你找工作，他们自己都没找过工作，怎么可能交给你实际的东西,因此必须要学会主动搜集有用信息。
搜集有用信息的方式：

i. 学会使用搜索引擎。

  凡事多去搜索，不要指望有人主动告诉你，任何问题的答案都是自己摸索出来的。另外不要认为搜索引擎很简单，熟练使用搜索引擎可以事半功倍（不要使用百度！ 有能力用Google就用Google，没有就用bing），可以学习这篇内容：https://zhuanlan.zhihu.com/p/70415957 99%的问题都可以通过搜索引擎解决。

ii. 多去了解行业动向和信息。

  可以向本专业或认识的一些已经在行业内有一定建树的前辈进行提问，向本专业站在顶端的导师们提问也完全可以，相信提问得当，大部分前辈都乐于回答，但在此之前，请先学会如何提问,坏的提问会很招人烦。

iii. 多去摸索，多去试错，多去了解。

  大学是与社会脱节的，那么如果你希望获取到最有用的信息，社会就是最好的学堂，有技术能力的就去实习，没有的可以利用业务时间去参加一些义务劳动或兼职，社会上能够学到很多在学校学不到的东西。
  但是！注意度量，很多行业或职业信息，了解一次就足够，例如奶茶店打工，你可以暑期兼职两个月，边打工边摸索奶茶店运营模式和细节，学会之后就没有必要再去兼职了，这种低价值劳动只会浪费你的时间。而对于自己希望从事的工作，例如学计算机的同学，多去中大厂或科研院所实习，大多数情况下都是多多益善的，每次不同公司的实习，都能给你带来不同的体验和收获。

iv. 跳脱出信息茧房。

  不要认为你所认为的就是正确的，不要被信息茧房束缚，要明确未来皆有可能，万事万物没有真确的道理。
  举个例子，有的同学很容易在学校和老师的引导下认为，自己学什么专业就只能去从事什么方面的工作，这是完全错误的。往大了看，很多从政风生水起的干部，专业都理工科，并非汉语言学或政治主修。往小了看，大厂很多年入百万程序员，也并非计算机科班出身，拿我身边来说，我有位同事本硕是法医专业，现在和我们一起在做后端开发。一切都是事在人为。
  学计算机的照样可能去做母猪的产后护理，学文学的照样可能从事工科研发，学数学的也可能去做HR，大学院系只是一个专业，仅此而已，不是你人生的全部，做你想做的事情，没有什么不可能。
2. 独立思考
  老生长谈的论点了，很多人的误区是，独立思考就是不听任何人的话，不从众，大家干什么我就反着来。这不叫独立思考，这是愚蠢。
  我认为真正的独立思考，是在收集巨量的客观信息进行整理之后，结合自己的主观思想，作出自身认为最能说服自己的观点。最典型的例子就是，很多人上大学前被家长和老师灌输唯读书论，仿佛不读书天要塌了，于是盲目考研，考公，考教资等等，总之不管什么东西，先考再说，考了就有用，但是，真的有用吗？所考的这个东西，对自己真的有价值吗？或者说对自己带来的收益和付出成正比吗？
  最有意思的例子就是我见过学计算机的学弟学妹抢着去考计算机二级证书的，仔细想想，学计算机的考P的计算机二级，有这种时间和精力多去刷两道算法题都比在那背计算机二级题库强。
  再举个例子，某些大学老师与校外考研机构勾结，渲染考研焦虑，打造所谓考研基地大学，把大学变成高中，让很多同学听从深感焦虑，一窝蜂涌向考研，且不说在学历贬值的当下，考研的ROI（投入与回报比）已经很低了，更何况但凡稍微了解一下就能知道，很多研究生都很扯淡，没有一点含金量，无非都是一个借口逃避现实罢了。
  在社会节奏异常快速的今天，学历的含金量在逐渐下降。而且很多人本就不适合考研，却将老师家长奉为真理，看不清自己的定位与未来。一问“为什么考研”，回答：“老师说不考研找不到工作”“我看大家都考，我也得考”“家里让我考，那我就考”。私以为，当你说出这些观点的时候，就算是侥幸上研，也是fw一个，未来进入社会，也大概率还是举步维艰。有考研自欺欺人的这时间和精力，还不如好好锻炼锻炼自己的综合能力。
  或许有人会反驳我，很多大厂很多岗位就是卡学历啊，不考研怎么进大厂？诚然，大厂卡校招学历，而且行情非常艰难是事实，但这和独立思考并无直接关系，我本意也并非不支持考研，我所反对的，是盲目不加以思考的考研，当然也包括考公，就是那种能说出“我看大家都考，我也得考“这种话的人。
  在我身边不乏有目标清晰的人，考研目的明确，“为了科研梦想”、“为了用高学历进入体制内发展”、“为了用高学历赚更多钱”、“本科专业不喜欢，所以考研为了从事自己想学的专业”，甚至哪怕是为了给自己争一口气，打脸某位前女友/前男友，这种也远比“我看大家都考，我也得考“要好一些，有清晰的目标，本质上就是有自己的一些独立思考在里面。
  当然，以上关于考研考公问题的论证也适用于其他所有的考证或就业，如果有人说出“我看别人都找工作，我也找工作”这种话，那也是一个无可救药的人。
  因此，没事多去思考，多去搜集信息，多和身边的人进行头脑风暴，锻炼自己独立思考的能力，不做无脑思考，人云亦云的人，也不要做完全反叛，反对一切可以反对的人。
3. 自驱学习
  这是一个比较鸡汤的观点，学习是一个比较反人类的东西，大多数人天生懒惰（比如我），但是学习又是不可轻视的一个东西，今天不学习，明天变垃圾。但是很多人又会在这个上面有一些误区，认为学习都很令人痛苦，甚至用学习无用论来逃避现实，亦或认为学习就是把书本教的学会，把老师上课讲的听懂，就叫学习。这些我认为都是对学习的误区。
  首先，学习未必是痛苦的，若你能从学习中得到正反馈，那学习就是有趣的。拿我举例子，在大学期间，我切实讨厌学校教的东西，认为读书很痛苦，但是我认为学技术非常有趣，我可以用爬虫整理自己喜欢的涩图（好孩子不要学），我可以用AI调教出专属女友或是让AI暴击校园群内的“诈骗学姐”，我可以使用Web技术建立自己的个人博客，我可以用QQ机器人写一个整活Bot来玩，这些东西的学习都让我感觉非常有趣且满足。并且如果你有了解国内一些比较牛逼的技术大牛，会发现他们大多数都是将技术作为自己的本源兴趣开展学习的（这也是为什么国人程序员好多二次元的间接原因）。
  也就是说，从学习中寻找自己的兴趣点，让学习给自己带来正向反馈。如果你在某些学习中实在找不到自己的兴趣点，只能感受到痛苦，并且这个痛苦会导致你几乎学不进去，三天打鱼两天晒网，那就换，换一个能给自己带来正向反馈的。最愚蠢的就是抱着一个自己压根不想学的东西硬啃，但是又不能持之以恒，三天大鱼两天晒网。（这里点名某些借着考研、考公混日子的人，既然学不进去，又坚持不动，那又何必骗自己呢）
  第二，学习不是别人告诉你，然后听懂就行了。纸上得来终觉浅，绝知此事要躬行，归根到底，学习只听懂别人所讲是不行的，别人教给你的，那是别人学会的，不是你学会的，听懂了和学会了是两个东西，小镇做题家认为听懂了会考试了就算学会，举个例子，在计算机专业，学校很多只会教开发数据库使用Mysql，但是很少告诉你，为什么惯例很多使用Mysql，为什么不用Redis，为什么不用PgSQL，难道是其他数据库不好用吗？而这些思考的答案，是在你听懂教授的知识后，自己去思考，去找资源，去从根源上理解，然后用学到的东西去实践，然后验证自己的答案，才能知道的，而把这个过程完成之后，才能真正称得上，学会了数据库。
  第三，学习不是仅限于学习知识。我自己将学习分为两种，一种是死知识，一是一，二是二，比如书本的知识，各种技术知识，往往都是固定的一套逻辑内容。还有一种是不固定的知识，或者叫通用知识，有点类似经验主义，比如如何表达，如何撰写好的文章，如何管理自己的时间和精力，如何与人相处等等，这些是需要大量实践才能总结学习出来的，并且需要多加留意、思考生活学习中的各种细节，而我们中国教育体系里最为缺乏的，就是对于学生这种通用知识的教育，很多人学习很好，技术很强，但是很多常识性的东西一塌糊涂，不懂怎么管理自己的时间，不懂怎么推动一个项目落地，不懂怎么与人沟通（我就是这种人，但我技术还很差）。
  这里重点说通用知识如何学习，对大学生来说，多去参加组织性的东西，比如实验室、学生会什么的，多去外出到真正的公司职场里实习，哪怕是很小的小作坊（但要有独立思考能力，别无脑过去被骗了），注意尽可能不要去接单，当乙方这种对结果导向非常强烈的工作，我们的目的是学习，不是做出成果，要让自己有一个即使什么都做不好也有回旋的余地。而且面向社会接单，一个没步入社会的黄毛小子怎么和人家老油条对线？到时候死都不知道怎么死的。
   对于初入大学什么都不懂的小萌新，建议可以试试辩论，辩论是一个非常锻炼通用技巧的东西，很适合内向的人破局。另外就是没事可以和自己的朋友去大谈政治，大谈新闻，哪怕是暴论，极端言论，目的不在于讨论是非，在于不经意间提高自己的逻辑能力和表达能力。（但注意不要在社交平台上对线，尽量私下面对面表达，谈不拢就真人快打.jpg）
4. 兴趣力
   兴趣是塑造一个人的基本，一切学习的开端始于兴趣，努力可以提高一个人的下限，但是兴趣可以提高一个人的上限。兴趣可以带给我们学习的正反馈，也可以是生活的调味剂，在大学期间多去拓展自己的兴趣爱好，丰富自己精神世界的同时，也说不定会在某个时刻带来意想不到的机会。这块就不细说了，毕竟我只是一个二次元死宅，没什么特别高尚的兴趣（。成为社畜以后也没什么机会拓展兴趣了，只是给不谙世事的学弟学妹一点我的建议。
社会现状
   简单说下我的见闻吧，当前的社会是快节奏社会，各行各业都在卷，对于像我一样出身平凡，长相平凡，能力的平凡的人来说，认清自己定位，了解社会现实是比较重要的。我们要接受社会不如意这个事实，甚至得接受现在的社会与百年前吃人的社会无本质区别的残酷现状，但是生活需要继续，同志仍需努力。
   钱多事少离家近的工作生活对于大多数人来说是一个相对理想化的东西，无资源无背景的人只能靠运气得到一份这样的工作，但是连刮刮乐都只能中20的大多数人，何来的好运呢。最典型的就是互联网的996工作，其他行业更甚，如果你觉得岁月真的静好，那真的只是大多数人在替你负重前行。多的是人拿着月薪三千的待遇干着堪比牛马的苦力，科比不一定真的看过凌晨四点的洛杉矶，但是北京马驹桥真的有凌晨四点的农民工，北京海淀真的有凌晨四点下班的程序员（如果觉得我说的有偏差，当我见识短浅即可，毕竟我也仅仅步入社会不到两年的时间）。
   因此社会现状并不如我们所理想的情况下，我们能做的就是接受并且努力向上，莫要听自暴自弃之流人的哭诉，摆烂躺平不能解决任何问题，我们改变不了世界，就去改变自己，钱当道的世界，唯有提升自己，积累原始财富，既包括自己能力的财富，也包括金钱的财富，多去拼，敢去拼，趁着年轻多试错，万一有一线机会呢，虽然社会残酷，但普通人尚有上升空间和机会，努力不一定会实现阶层跃迁，但能赚点钱让自己有去看世界的底气。摆烂躺平，随波逐流，终会埋没在时代的洪流里面。
选择
   选择大于努力，如我前面所说，我们每个人只是时代的一粒尘，随便一股风就可能吹跑，随便一滴雨就可能把我们打在地上，但是如果乘上时代的风，那就是乌鸦变凤凰，雷军说过站在风口上猪都能飞起来，也是这个道理，选择了对的方法，仅需很少的努力便可以起飞，选错了方向，寒窗苦载二十年，终是默默无闻。
   如何做好选择？结合我前面所说，多方面的信息来源，强大的独立思考能力，强大的学习能力与执行力，这些是做出一个好选择的前提。（如果家里有矿的，可以忽略），没有好的信息来源，吃shi都赶不上热乎的，就好像国庆前的那波股市大涨，很多人看到别人赚钱了才入场，直接成为韭菜狠狠被收割，而聪明的人懂得提前洞察信息，已经赚的盆满钵满套现离场。没有强大的独立思考能力，就会被别人误导，我大学期间见过许多人，整个大学都被家里安排，原本可以选择自己感兴趣的计算机，但是家里人认为土木工程更牛逼！然后嘛，，，，稍微懂得人应该都知道下场了，任何人都有思考的局限性，人只能想象自己见识过的东西，你所听到的东西，一定是别人想让你听到的，教你赚钱的人一定不是想你赚钱，而是想赚你的钱，所以更显自主独立思考的重要。没有强大的学习和执行能力，那就是看着别人赚钱眼红后悔自己为什么当初没有去做罢了，无需多说。
结语
综上所言，希望读完我的文章能够对读者有所帮助，或许其中有些观点尚显稚嫩或是有所偏差，但若能引发你一定程度的思考，也算不枉所写、特别是处于象牙塔里被保护的很好的大学生们，希望能够早日意识到自我，做好自己的大学乃至人生规划。
PS
如果你读完觉得有些地方有偏差或者有想更深一点了解的，想与我讨论下，欢迎留言或发Email联系我，我乐意友好地交流一下。
]]>
            i@umb.ink (伞菌)
            感悟
        
        
            
            https://umb.ink/post/26
            https://umb.ink/post/26
            Thu, 07 Mar 2024 17:39:20 GMT
            将之前写的线稿算法部署了一下

点我快速体验

]]>
            
      
      
      
      
将之前写的线稿算法部署了一下

点我快速体验

基本效果：

提取后：




请求体
请求URL：https://service.umb.ink/art/img
Method :   POST
RequestForm: 将img作为data放在FormData中进行请求
{
	"file": fileData
}

Response：处理完成后的线稿图像为二进制流PNG图片
示例
function postData() {
        var xmlhttp;
        xmlhttp=new XMLHttpRequest();
        var formData = new FormData();
        formData.append("file", data);
        xmlhttp.open("POST",basePath+"/img",true); // 请求图片
        xmlhttp.responseType = "blob";
        xmlhttp.onload = function(){
            console.log(this);
            if (this.status == 200) {
                var blob = this.response;
                var img = document.getElementById("result-image"); // 渲染到img标签
                img.onload = function(e) {
                    window.URL.revokeObjectURL(img.src);
                };
                img.src = window.URL.createObjectURL(blob);
            }
        }
        xmlhttp.send(formData);

    }
    //赋值变量
    var basePath = getContextPath();
    // 获取项目路径
    function getContextPath() {
        return "http://101.34.24.60:8008"
    }

]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/24
            https://umb.ink/post/24
            Tue, 31 Dec 2024 10:31:42 GMT
            我的2023年度工作总结
因为最近事情比较多，比较忙，迟来的工作总结，回顾23年，对于我是充满忙碌、变化与挑战的一年，这一年曲折坎坷，终是轻舟已过万重山。
]]>
            
      
      
      
      
我的2023年度工作总结
因为最近事情比较多，比较忙，迟来的工作总结，回顾23年，对于我是充满忙碌、变化与挑战的一年，这一年曲折坎坷，终是轻舟已过万重山。

2024.3.10更新：拿到了23年度的某手洛子峰奖（全都仰仗大佬们）、有幸拿到了所属线的踏实进取奖，瞬间感觉自己一年的付出得到了认可。
2023 Q3、Q4所参与的项目：
1. 内部网络工具APP：

角色：Android研发支持
工作内容：编写Android底层网络信息与信号强度的检测工具类，封装底层接口
产出：协助了内部工具网络检测功能性技术方案的验证
自我评价：后半年Android原生侧需求较少，因此并没有很多的工作内容，但参与的网络检测功能性技术方案的验证较为顺利。

2. 班车系统：

角色：技术主R
工作内容：完成了新版本班车设备系统的研发工作，完成班车APP与管理后台的研发，攻克实际业务场景下的痛点
产出：解决了班车系统在极端弱网环境下无法使用、现场人力维护成本高的痛点，完成了上线和交付工作，业务运行相对稳定。
自我评价：在此前没有接触过车机设备的情况下，接手这个项目还是比较有挑战性的，在过程中也踩了非常多的坑，也学到了很多，并且第一次意识到了产品和沟通管理对一个项目的重要性。对个人来说，经过这个项目，意识到自己还有很多需要改进的地方，是一次很好的成长。（我自己一个人做客户端+后端+主R，感觉还是蛮nb的）

3. 会议室预约屏：

角色：技术主R
工作内容：

开发会议室预约屏信息展示优化、自动巡检、设备自动开关机等功能
开发会议室预约屏管理平台


产出：

完成累计一千多会议室的预约屏全量上线工作
上线会议室预约屏自动开关机、自动巡检策略，降低设备故障率到10%内
参与开发并上线了会议室预约屏管理平台，提高会议预约屏维护效率


自我评价：预约屏的相关需求迭代开发和上线都相对较为顺利，也较为快速，个人对自己在预约屏项目上的表现较为满意。

4. 智能化会议室：

角色：研发支持
工作内容：

实现会议室人体存在、开关数据的投票算法和数据入库。
完成会议室智能化电视集控的开发


产出：协助完成了会议室智能化数据看板的搭建工作，完成了电视集控的灰度上线
自我评价：

在数据看板中，对于大型数据的处理此前没有相关经验，外加同时期精力相对有限，导致初期项目进展并不顺利，数据入仓代码较为混乱，集成开发较为困难，并且上线测试后还出现了部分数据不准的问题，数据库内写入超千万量级的数据维护起来也很费劲，然后替换了旧有的数据格式，替代为相对简洁的投票机制，希望在24年度无极看板能够完美上线运行。
在会议室集控项目中，因此前有对接绿米SDK的经验，因此相对开发和灰度上线都相对较为顺利，同时还完成了海信电视APP集控的方案测试验证，因此相对较为满意。



5. 内部资源管理平台（CMDB）：

角色：后端研发支持
工作内容：

基于Casbin实现平台权限管理和审计模块的开发。
实现网络管理平台的CMDB资源Excel模板文件的上传与下载


产出：

完成了权限管理模块的研发与上线，并对服务进行了解耦和优化
完成了CMDB资源Excel模板文件的上传与下载功能。


自我评价：

在权限管理中，自己之前没有接触过RABC模型和Casbin开发，通过这次的权限管理需求，首次了解并且学习了RABC模型和Casbin的使用，并且独立解决了多容器场景下Casbin数据无法正常同步的问题，对自己有较大的成长。
在会议室集控项目中，因此前有对接终端传感器的经验，因此相对开发和灰度上线都相对较为顺利，同时还完成了电视APP集控的方案测试验证，因此相对较为满意。



对自己的评价

关键字：成长、变化

自入职后的23后半年学到了非常多的东西，不仅仅包括技术上的，也包括很多通用性的能力，包括文档撰写、项目管理、沟通等。在工作的半年，自己的提升非常大，感觉自己这半年是充实且充满成长性的半年。
但是半年中也发现了自己在职场中存在的一些缺点和不足，包括沟通能力不强，不能很好的主动和人进行有效沟通；信息传递意识不强，很多信息不能及时同步到上级与项目相关方；不能很好地管理自己的精力与排期；偶尔会管理不好自己的压力情况等，希望下年度能够有所进步。
总的来说23年的工作个人打分：7分/10分，欠缺3分为沟通一分、压力管理一分、技术目标未达到个人预期一分。
工作中迷惑的地方
排期问题：在业务中经常会遇到无法预估排期的问题，先前并没有相关经验，单靠调研并不能准确预估排期时间，排期多了和少了都会有问题，反而会造成压力，导致项目效果不理想。
24年度的规划

技术规划：


在维持正常业务开发的基础上，侧重于后端技术的扩展与提高，学习分布式、微服务、RPC等后端技术栈，弥补后端技术短板的情况
在安卓侧想办法整理出较为完善的个人技术架构，包括BaseLauncher、Iot应用快速搭建脚手架等，提高开发效率


通用能力规划：


适当处理好自身心态，寻求压力与工作平衡点，锻炼与人沟通技术。

24年度目标：

技术上熟练后端各类技术栈，研究各类后端架构，并编写一些技术性验证demo发布到博客或Github。
通用能力上锻炼自身沟通能力。

]]>
            i@umb.ink (伞菌)
            感悟
        
        
            
            https://umb.ink/post/23
            https://umb.ink/post/23
            Sun, 21 Jan 2024 11:56:15 GMT
            又到一年毕业季，新的韭菜要进入社会被噶了，这里写篇博客给一些自己短浅的建议供计算机相关专业的学弟学妹们参考。


免责声明：因本人经验短浅，本文章仅供计算机相关专业参考，对其他专业可能不具有参考价值，并且本文章仅为本人建议，仅供抛砖引玉，引发读者自身思考，读者的个人决定与本人无关。

毕业——考研？就业？考公？
]]>
            
      
      
      
      
又到一年毕业季，新的韭菜要进入社会被噶了，这里写篇博客给一些自己短浅的建议供计算机相关专业的学弟学妹们参考。

免责声明：因本人经验短浅，本文章仅供计算机相关专业参考，对其他专业可能不具有参考价值，并且本文章仅为本人建议，仅供抛砖引玉，引发读者自身思考，读者的个人决定与本人无关。

毕业——考研？就业？考公？

选择
毕业后对于普通的大多数来说，大家无非就三种去向，考研、就业和考公，这里我结合我自己的一些经验分享一下我的看法。
这三种选择建议最好结合自身情况与调研实际情况去决定，多去咨询相关学长学姐去了解就业/考研/考公的实际情况。

考研/考公 本人没了解过，这里不作过多篇幅，但是如果你不知道自己要干啥，而是随大流去考研/考公，并且自己的自制力没有那么好，那么建议滚去就业，不要浪费自己的时间，并且各个厂很少有招聘往届生的机会，也就是最好不要指望考研没上继续二战，最后再找工作，机会只有一次。

就业
对于学计算机的同学来说，若本科就业，首选央企、互联网中大厂，次选国企小厂，不建议去外包（包括华为od）。

现实情况：现在计算机就业市场存在饱和，各个中大厂逐渐减少校招名额和比例，各家都在降本增效，拿到中大厂offer的难度与日俱增。同时很多下岗大厂员工投身进入所谓的“程序员速成班”，越来越多不明觉厉的人进入互联网企业做起了外包，导致大厂的用人倾向逐渐倾向外包化，在可预见的未来互联网行业只会越来越卷。
自身条件：进入中大厂的水平要求较高，如果你大学三年都没有很好地积累非常扎实的技术栈和较多的项目开发经验，那么卷中大厂绝对不是一个好的选择。

如果你熟悉Java、Python、Go、Js等任意技术栈（有熟练理解其底层原理），并且至少刷完了力扣100题，那么好好准备可以冲大厂了。


中大厂/央企/国企/小厂 区别：

本质上不论去哪种性质的企业，作为程序员，干的活基本都是差不多技术水平的（算法岗除外），面试造火箭，工作拧螺丝就是这个道理。
中大厂的优势：平台大、相对机会多，流程规范，优势项目经验多，大厂经验会非常宝贵。
中大厂劣势：压力大、裁员可能高、没有个人时间
中大厂适合什么人：技术水平高、喜欢打拼、想赚钱
央企/大型国企优势：平台大、环境相对轻松、稳定，福利高
央企/大型国企劣势：门槛高
央企/大型国企适合什么人：学习成绩优异、党员、想进体制但是不想考公，家里有背景。
小厂/边缘国企的优势：环境轻松、门槛低、部分有后发潜力
小厂/边缘国企劣势：待遇低、技术质量低、对个人提升很难没有促进
小厂/边缘国企适合什么人：技术力差，学习中等，喜欢轻松的生活工作



思想
我们大学的教育与社会是极其割裂的，在脱离大学进入社会前，一定要转变自己的思想。自信、善于表达自己、适度地装逼表现自己，要比闷头苦干的人更适合社会节奏。
同时学会与人沟通，换位思考，与人沟通的能力在职场中远大于个人技术能力，在实际职场中，沟通占7分，技术占3分，但请注意对于校招生来说，技术依然是首选项，沟通能力仅是能助我们走的更远，不代表技术就不重要。
学会大胆表现自己，不要担心在面试官或领导面前表达出来会班门弄斧，如果你在大学期间加入了实验室，并且取得了一些A类赛事的国奖，熟读了一门或几门技术栈，有自己独立开发项目的能力，那么你已经超越了至少50%的同龄人（包括985/211），如果你有这样的能力，你是很牛逼的。
推荐一本书：《跃迁》https://book.douban.com/subject/27078435/
就业准备？


渠道
Boss直聘（相对最靠谱）、智联招聘（国企、传统企业偏多）、牛客（校招、实习）、实习僧（实习）


简历
简历是非常重要的一个点，简历的好坏直接决定了面试官对你的第一印象，对于计算机专业的来说，简历应该包含下面的几个要素：



个人基本信息，（学历、专业、绩点、邮箱、电话、微信、个人照片），个人信息尽量直观、精简，不要写学生班干部经历什么的，技术岗位没人管你是不是班干部
掌握技术栈：视你投递的岗位和个人技术积累而定，比如你投递java后端，那么技术栈就尽量写SpringBoot、Mysql等，如果投递的是Web前端，就写写熟悉Js、Vue、React等技术栈。
项目经历：这里最为重要，项目经历尽量写的一眼能看明白你在项目里做了什么、有什么成就，可以参考STAR原则去写，即项目是什么？你的角色是什么？你做了什么？过程是什么？结果是什么？这样写出来的最为直观。


获奖：  可以写写自己获得的省级以上奖项，校级以下的没必要写，没有任何含金量
其他经历：包括社团主席、赛事组织负责人等可以写写，如果是班干部之类的任职，没有必要写。



心态
放平心态，找工作70%靠的是运气，30%靠的是实力，很多时候你可能比其他人技术更好，能力更强，但是面试官选择了另一个人，挂了你，不是你不行，而是刚好另一个人运气好，更贴合面试官的喜好和岗位匹配度。本人之前校招的时候三个月投递了380+公司，面试了一百多场，最后也才拿到了四五个offer，很多时候放宽心去做就好了。



但行好事，莫问前程。


多在几颗树上吊死，总能成一个。



方向选择：

前端？后端？客户端？
就现在个人感觉来说，后端和前端的岗位还是蛮多的，AI算法岗对本科几乎没有任何机会，因此推荐继续卷前端后端，客户端发展有局限性，即使校招进去后也需要转前后端，否则容易被淘汰。测试岗位不推荐，但是可以考虑，在大厂中测试岗位相对其他来说门槛会低一点，但是对个人提升也比较有限。


技术
背八股已经是基本要求了，更多注重技术与业务结合，思考一个算法或代码特性可以在什么场景中使用会更有加分。



力扣算法
拿得出手的项目（学习STAR原则对项目进行整理）
熟读技术八股文

]]>
            i@umb.ink (伞菌)
            感悟
        
        
            
            https://umb.ink/post/22
            https://umb.ink/post/22
            Mon, 08 Jan 2024 17:11:00 GMT
            最近闲来无事，折腾一下很久之前已经火完了的Stable Diffusion。这篇博客主要说明如何快速在有英伟达显卡的电脑上部署一份Stable Diffusion以及如何引入自己希望的模型。

]]>
            
      
      
      
      
最近闲来无事，折腾一下很久之前已经火完了的Stable Diffusion。这篇博客主要说明如何快速在有英伟达显卡的电脑上部署一份Stable Diffusion以及如何引入自己希望的模型。

本人部署用环境：

CPU：AMD 5600X
GPU：RTX3060
RAM：32GB

1.确定相关网址

SD-WebUI Github : SD经典UI仓库 https://github.com/AUTOMATIC1111/stable-diffusion-webui
HuggingFace: 用于下载各类所需模型,模型类型非常多 https://huggingface.co/
civitai: 用于下载各类所需模型，更加直观一点，https://civitai.com/models/119012/bluepencil-xl

2. Clone仓库
打开你的Terminal，Clone SD WebUi仓库，在此之前请保证你的电脑有Git环境、cuda环境和python环境，关于如何安装Git请自行百度/知乎
git clone git@github.com:AUTOMATIC1111/stable-diffusion-webui.git

3.下载models
在HuggingFace或c站都可以任意选择一个model进行下载，我这里使用的是https://civitai.com/models/119012/bluepencil-xl 这个模型



下载完成后，将下载好的model文件放在.\stable-diffusion-webui\models目录下即可
4 启动SD
点击运行.\stable-diffusion-webui下的webui-user.bat文件，会弹出一个终端执行框，等待其自动配置完成即可
如果出现错误，请检查你的cuda环境和Python环境是否正常


5 成品

参考prompt：
anime, cute girl, wizard hat, kimono, thigh-highs, happy, dynamic pose, "HAPPY NEW YEAR!", 2024, pop font, landscape, sunrise, winter, red tone color, bloom effect, ambient occlusion, Bokeh, depth of field
speed：1360477511
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/21
            https://umb.ink/post/21
            Thu, 12 Oct 2023 08:15:09 GMT
            问题描述
在Golang服务端使用Casbin作为权限管理的场景下，会增加多个Casbin实例来保证请求高并发和稳定性，但是与此同时会出现多个实例接口返回的数据不一致的问题，这种问题会严重影响业务使用。
]]>
            
      
      
      
      
问题描述
在Golang服务端使用Casbin作为权限管理的场景下，会增加多个Casbin实例来保证请求高并发和稳定性，但是与此同时会出现多个实例接口返回的数据不一致的问题，这种问题会严重影响业务使用。

问题原因
在Casbin的设计中，为了保证高并发下的可观性能，Casbin内置一个内存缓存，每当执行读数据的动作时，会先获取内存缓存中的数据，而不是数据库的数据。
因此在多实例场景下，当一个实例的Casbin数据发生变更时，其它实例的Casbin缓存并没有及时同步刷新，这就导致了当请求被分发到对应的实例上时，获取到的依然还是旧的错误数据。
问题解决
Casbin官方提供了一种可行的解决方法——Watcher机制，可以阅读对应文档CasbinWathcer
文档中说明了casbin支持使用Redis、Kafka、zookeeper等中间件实现多实例之间的数据同步
我采用了成本较低的Redis作为Watcher，下面是我的代码参考：

Watcher回调函数：

// 这是一个包装方法，方便传入Enforcer实例来实现回调中对casbin的操作
func ConsumeCallback(e *casbin.Enforcer) func(msg string) {
	return func(msg string) {
		zap.L().Info("enforcer update msg:" + msg)
                // 在接收到任意的权限变更后，刷新Enforce实例，达到刷新缓存的目的
		e.LoadPolicy()
	}
}

需要注意的是我们这里给到的回调函数必须是func(msg string)的形式，因为Casbin Watcher规定了回调到的方法只会给到一个Msg信息，剩下的需要我们自己处理。
具体的MSG信息官方文档并没有给出，不过我在实际测试过程中有总结到一个大的结构体对象可以供有需要的进行参考
// 回调中给到的msg的结构大概就是下面struct中定义的样子
type MSG struct {
	Method      string
	ID          string
	Sec         string
	Ptype       string
	Params      interface{}
	NewRules    interface{}
	OldRules    interface{}
	NewRule     interface{}
	OldRule     interface{}
	FieldValues interface{}
}

func (m *MSG) MarshalBinary() ([]byte, error) {
	return json.Marshal(m)
}

// UnmarshalBinary decodes the struct into a User
func (m *MSG) UnmarshalBinary(data []byte) error {
	if err := json.Unmarshal(data, m); err != nil {
		return err
	}
	return nil
}


Casbin注册回调函数

func (c *CasbinOptions) Init(db *gorm.DB) (*casbin.Enforcer, error) {
	w, _ := rediswatcher.NewWatcher(viper.GetString("redis.addr"), rediswatcher.WatcherOptions{
		Options: redis.Options{
			Network:  "tcp",
			Password: "redis.password",
			DB:       "redis.iotDB",
			PoolSize: "redis.poolSize",
		},
		Channel: "/casbin",
		// 忽略容器自身发起的订阅消息推送，防止出现死循环
		IgnoreSelf: true,
	})

	adapter, err := gormadapter.NewAdapterByDB(db)
	if err != nil {
		zap.L().Error("casbin adapter init error:" + err.Error())
		return nil, err
	}
	e, err := casbin.NewEnforcer(c.Path, adapter)
	if err != nil {
		zap.L().Error("casbin enforcer init error:" + err.Error())
		return nil, err
	}
        // 设置RedisWatcher
	_ = e.SetWatcher(w)
        // 设置回调函数
	_ = w.SetUpdateCallback(ConsumeCallback(e))
	err = e.LoadPolicy()
	if err != nil {
		zap.L().Error("casbin policy init error:" + err.Error())
		return nil, err
	}
	_ = e.SavePolicy()
	return e, nil

}

完成后重新运行验证效果即可
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/20
            https://umb.ink/post/20
            Wed, 11 Oct 2023 07:25:29 GMT
            一、引言
代码整洁的重要性
代码整洁是软件开发中至关重要的一个方面。当我们编写整洁的代码时，可以提高代码的可读性、可维护性和可扩展性。整洁的代码易于理解，减少了他人阅读和维护代码时的困惑和错误。同时，整洁的代码也有助于减少bug的产生，提高软件的质量。
]]>
            
      
      
      
      
一、引言
代码整洁的重要性
代码整洁是软件开发中至关重要的一个方面。当我们编写整洁的代码时，可以提高代码的可读性、可维护性和可扩展性。整洁的代码易于理解，减少了他人阅读和维护代码时的困惑和错误。同时，整洁的代码也有助于减少bug的产生，提高软件的质量。

代码整洁的好处


可读性：整洁的代码易于阅读和理解，减少了他人阅读代码时的困惑和错误。清晰的代码结构和命名规范使得代码逻辑更加明确，提高了团队协作效率。（简单来说就是要让一起协同工作的人能读懂你的代码，而不是一坨答辩）


可维护性：整洁的代码易于维护。清晰的代码结构和模块化设计使得修改和扩展代码更加容易。通过遵循一致的编码风格和注释规范，他人能够更快速地理解代码的意图和实现细节。（


可测试性：整洁的代码易于进行单元测试和集成测试。清晰的函数和类设计使得测试代码更加简洁和可靠。通过良好的错误处理和异常处理机制，能够更好地捕获和处理错误，提高代码的健壮性。


可扩展性：整洁的代码易于扩展和重构。良好的代码结构和设计原则使得添加新功能或修改旧功能时能够保持代码的灵活性和可扩展性。通过避免代码的重复和冗余，减少了后续维护的工作量。


二、代码命名
在编写代码时，良好的命名是十分重要的，它能够提高代码的可读性和可理解性。以下是关于命名的几个要点：


使用有意义的变量名：变量名应该能够准确地描述变量的用途和含义。例如，如果我们需要表示一个人的年龄，可以使用age作为变量名，而不是使用无意义的字母或数字。


避免使用含糊不清的缩写：尽量避免使用难以理解的缩写，因为缩写可能会使代码的可读性降低。例如，如果我们需要表示一个订单的创建时间，可以使用creationTime作为变量名，而不是使用缩写形式如ct。


统一的命名风格：在整个代码库中保持统一的命名风格是很重要的。例如，可以选择使用驼峰命名法或下划线命名法，并在项目中保持一致。例如，如果我们使用驼峰命名法，可以将一个变量命名为firstName，而不是first_name或FIRSTNAME。（一般对于Java、Golang而言我们更喜欢使用驼峰命名，而对于c/c++、python或脚本语言更喜欢使用下划线命名）


避免误导性的命名：命名应该准确地反映变量或函数的用途，避免使用与其实际功能不符的名称。例如，如果我们有一个函数用于计算圆的面积，可以将其命名为calculateCircleArea，而不是calculateRectangleArea。


避免使用中文拼音：很多初学者，特别是一些没有接触编程或从某些培训班体系出来的程序员会非常喜欢使用中文拼音来命名变量，这是非常不好的习惯，比如下面的代码：
String diYiXueQi  = "第一学期"

如上面的变量，很容易引起误解，读者在阅读代码时，很难第一反应了解到这个diYiXueQi到底代表什么，而使用英文可以很顺畅地表达我们的想法。


三、函数
在编写代码时，函数是组织和封装逻辑的基本单元。函数设计的好不好直接决定了项目的鲁棒性和耦合度。

下面我通过python来举例什么是好的函数：

函数的简洁性和清晰性：函数应该保持简洁和清晰，只关注单一的任务或功能。避免函数过于复杂和冗长，可以通过拆分函数、提取子函数等方式来简化函数的逻辑。

# 不好的示例：复杂且冗长的函数
def process_data(data):
    # 复杂的数据处理逻辑...
    # ...
    # ...
    # ...
    # 复杂的数据处理逻辑...
    # ...
    # ...
    # ...
    # 复杂的数据处理逻辑...
    # ...
    # ...
    # ...
    # 复杂的数据处理逻辑...
    # ...
    # ...
    # ...

# 好的示例：简洁清晰的函数
def process_data(data):
    preprocess_data(data)
    transform_data(data)
    analyze_data(data)
    save_data(data)


函数的单一责任原则：每个函数应该只负责一个明确的任务或功能，并且只做这一个任务。这样可以提高函数的可重用性和可测试性，同时也使得代码更易于理解和维护。

# 不好的示例：一个函数负责多个任务
def process_data(data):
    preprocess_data(data)
    transform_data(data)
    analyze_data(data)
    save_data(data)

# 好的示例：每个函数只负责一个任务
def preprocess_data(data):
    # 数据预处理逻辑...

def transform_data(data):
    # 数据转换逻辑...

def analyze_data(data):
    # 数据分析逻辑...

def save_data(data):
    # 数据保存逻辑...


函数的命名和参数选择：函数的命名应该能够准确地描述函数的功能和作用。选择有意义的函数名和参数名，可以让代码更易于理解和使用。

# 不好的示例：函数名和参数名不具备描述性
def calc(a, b):
    # 计算逻辑...

# 不好的示例：使用缩写和无意义的参数名
def process_data(d):
    # 数据处理逻辑...

# 好的示例：具有描述性的函数名和参数名
def calculate_sum(num1, num2):
    # 计算两个数的和...

def process_data(data):
    # 数据处理逻辑...


避免过长的函数：函数应该尽量避免过长，超过一屏幕的长度。长函数难以理解和维护，可以通过拆分函数或提取子函数来减少函数的长度。

# 不好的示例：过长的函数
def process_data(data):
    # 长长的处理逻辑...
    # ...
    # ...
    # ...
    # 长长的处理逻辑...
    # ...
    # ...
    # ...
    # 长长的处理逻辑...
    # ...
    # ...
    # ...

# 好的示例：拆分和提取子函数
def process_data(data):
    preprocess_data(data)
    transform_data(data)
    analyze_data(data)
    save_data(data)

def preprocess_data(data):
    # 数据预处理逻辑...

def transform_data(data):
    # 数据转换逻辑...

def analyze_data(data):
    # 数据分析逻辑...

def save_data(data):
    # 数据保存逻辑...


函数的注释和文档：为函数提供清晰的注释和文档，可以帮助其他开发人员理解函数的用途、输入和输出。注释应该简洁明了，解释函数的功能和关键步骤，而文档可以提供更详细的说明和示例。

def calculate_sum(num1, num2):
    """
    计算两个数的和

    Args:
        num1 (int): 第一个数
        num2 (int): 第二个数

    Returns:
        int: 两个数的和
    """
    return num1 + num2

四、注释
注释是用来解释代码意图、提供额外信息并帮助理解代码的文字说明，注释的存在不仅仅是帮助别人理解你的代码，也是帮助未来的自己在维护时能够想起代码是干什么的（对于某些自己写的远古项目，如果你没有注释，那么那份代码可能只有上帝知道是干什么的）：


注释的作用和使用场景：注释的主要作用是解释代码的意图、提供上下文信息以及帮助其他开发人员理解代码。注释的使用场景包括：

解释代码的目的和功能。
提供算法或逻辑的解释。
强调特殊的注意事项或约束条件。
提供对代码的修改或优化的说明。
文档函数、类或模块的用途和使用方法。

注释应该在需要解释的地方使用，并且应该与代码保持同步，以确保注释的准确性和有效性。


注释应该解释代码的意图而非实现细节：注释应该关注代码的意图和目的，而不是详细描述代码的实现细节。代码本身应该尽可能自解释，而注释则应该解释代码为什么要这样做，以及代码的目的和预期结果。
# 不好的示例：注释过多的实现细节
def calculate_sum(num1, num2):
    # 将num1和num2相加
    result = num1 + num2
    return result

# 好的示例：注释解释代码的意图
def calculate_sum(num1, num2):
    # 计算两个数的和
    result = num1 + num2
    return result



避免无用或误导性的注释：注释应该是有用的，不应该存在无意义或误导性的注释。避免在代码中添加显而易见的注释，注释应该提供额外的信息，帮助理解代码。
# 不好的示例：无用的注释
result = num1 + num2  # 计算结果

# 好的示例：提供额外信息的注释
# 将num1和num2相加得到结果
result = num1 + num2



注释的更新和维护：注释是与代码同步的重要部分，应该随着代码的修改和演进进行更新和维护。当代码发生变化时，相应的注释也需要相应地更新，以保持注释与代码的一致性。
注释应该被视为代码的一部分，同样受到代码审查和维护的过程。确保注释的准确性和完整性，以便其他开发人员能够依赖和理解注释提供的信息。


五、格式化
代码的格式化对于代码的可读性和可维护性非常重要，如果你的代码没有合理的格式化，那么非常容易让你的代码看起来像一大坨💩。

通过合理地使用缩进、空格、折行和空行，我们可以使代码更易读、易于理解和维护。保持一致的格式化风格，并遵守通用的格式化准则，有助于提高代码的可读性和一致性：


代码的缩进和对齐：使用一致的缩进风格来展示代码的结构和层次关系。常见的缩进方式是使用四个空格或者一个制表符（Tab）。对于每个代码块，都应该有相同的缩进级别，以便于阅读和理解代码的逻辑。
# 不好的示例：缩进不一致
if condition:
print("Condition is true!")
   print("Indented inside if block")

# 好的示例：一致的缩进
if condition:
    print("Condition is true!")
    print("Indented inside if block")



空格的使用：在代码中适当地使用空格可以提高代码的可读性。以下是一些常见的空格使用场景：

在运算符两侧和逗号后面添加空格，以增加可读性。

# 不好的示例：缺少空格
result=a+b

# 好的示例：添加空格
result = a + b


在函数的参数列表和元素列表中，逗号后面添加一个空格。

# 不好的示例：缺少空格
my_function(arg1,arg2,arg3)

# 好的示例：添加空格
my_function(arg1, arg2, arg3)


在注释中，运算符和关键字后面添加一个空格。

# 不好的示例：缺少空格
#计算两个数的和
result = num1+num2

# 好的示例：添加空格
# 计算两个数的和
result = num1 + num2



行的长度和折行规则：为了保持代码的可读性，应该遵守适当的行长度限制。通常，建议将每行代码限制在80个字符以内。如果一行代码超过了限制，可以使用括号、反斜杠或换行符进行折行。
# 不好的示例：过长的行
long_line = "This is a very long line of code that exceeds the recommended line length and makes it hard to read and understand."

# 好的示例：使用括号进行折行
long_line = ("This is a very long line of code that exceeds the recommended line length "
             "and makes it hard to read and understand.")

# 好的示例：使用反斜杠进行折行
long_line = "This is a very long line of code that exceeds the recommended line length " \
            "and makes it hard to read and understand."

# 好的示例：使用换行符进行折行
long_line = "This is a very long line of code that exceeds the recommended line length\n" \
            "and makes it hard to read and understand."



空行的使用：适当地使用空行可以增加代码的可读性，将代码分成逻辑块和功能块。以下是一些常见的空行使用场景：



在函数和类之间使用空行，以及在函数内部的逻辑块之间使用空行，以增加代码的可读性。

def function1():
    # 代码逻辑...

def function2():
    # 代码逻辑...

class MyClass:
    # 类定义...

function1()

function2()


在函数和类的定义之前使用空行，以增加代码的可读性。

import module1

import module2


def my_function():
    # 代码逻辑...


class MyClass:
    # 类定义...


在代码的不同部分之间使用空行，以增加代码的可读性和分组。

import module1

import module2


def function1():
    # 代码逻辑...


def function2():
    # 代码逻辑...

]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/18
            https://umb.ink/post/18
            Thu, 30 Mar 2023 14:22:51 GMT
            ChatGPT好使是有目共睹的，特别对于我这种懒狗，但是相对的ChatGPT受限于某些神秘力量，导致在使用它的时候比较麻烦，而OpenAI官方为了解决这些问题给出了可以快速集成到个人应用中的APPKEY，因此出现了一些可以一站式解决的傻瓜式ChatGPT部署方案。

]]>
            
      
      
      
      
ChatGPT好使是有目共睹的，特别对于我这种懒狗，但是相对的ChatGPT受限于某些神秘力量，导致在使用它的时候比较麻烦，而OpenAI官方为了解决这些问题给出了可以快速集成到个人应用中的APPKEY，因此出现了一些可以一站式解决的傻瓜式ChatGPT部署方案。

我这里采用ChatBot-WebUI这个开源库来快速部署
前期准备
你需要一个APP_KEY,可以从这里获取，当前前提是你拥有一个可以正常使用的ChatGPT账号。

如果你不懂得什么叫接码平台，也不懂得什么叫互联网虚拟混砖逾越技术，可以找你认识的，有chatGPT账号的朋友Py一个Key
开始

Fork chatbot-ui仓库到自己仓库
访问https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fmckaywrigley%2Fchatbot-ui  使用Vercel快速部署chatbot-ui（其实官方都给弄好了，剩下的自己搞就完了）按它的一路点点点就行
完成以后是这样的：



6. 这时可以尝试访问它给到你的DOMAINS里的链接，同样的如果你有自己的域名，可以添加DNS记录来快速访问它（不要忘记去CF上给自己的域名加记录）：


7. 部署完成以后访问，你会看到如下页面：


8. 将你的APPKEY粘贴到左下角的OpenAI API 密钥中：


开始你的ChatGPT对话就可以了
PS如果希望持久化APPKEY，让别人一打开就可以用的话，你需要向仓库里添加一份.env.local配置文件，参考官方的README



添加之后重新让Vercel构建一下，再部署，就可以啦
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/15
            https://umb.ink/post/15
            Fri, 04 Nov 2022 13:04:40 GMT
            最近维护几个老旧的服务（shi山），并且源代码已经莫得了，只有生产环境的几个jar包，但是要对里面的一些配置进行一些更改，因此尝试做了一下简单的jar解包

]]>
            
      
      
      
      
最近维护几个老旧的服务（shi山），并且源代码已经莫得了，只有生产环境的几个jar包，但是要对里面的一些配置进行一些更改，因此尝试做了一下简单的jar解包

环境
MacOS && Linux均可
解包
使用指令


.class文件都在BOOT-INF下



lib文件夹是程序依赖的lib库

classes文件夹就是包括了所有的.class文件

.class文件是Java的二进制支持文件，所以我们需要进行逆向还原出Java源文件

办法很简单，直接使用IDEA打开该目录，IDEA内置.class文件自动逆向还原，只可惜权限是read only

像这样：




这样的话就可以查看到逆向后的.class文件源码了（甚至是kt代码）
替换
如果需要修改的文件或者配置，直接cv逆向后的文件代码（虽然它是read only，但是可以复制），复制到任意一个Java文件中，然后用java -c 进行编译打包为.class文件，然后把原来BOOT-INF下的对应.class文件直接进行替换即可
重新打包
替换完成后需要重新把这些文件打包回jar包，使用下面的指令（在解包目录下）：
技术
        
        
            
            https://umb.ink/post/14
            https://umb.ink/post/14
            Thu, 07 Mar 2024 05:16:54 GMT
            起因

由于服务器到期的原因，最近对Blog做了一下迁移，原本计划由腾讯云迁移到阿里云，但是发现那样的话还必须把备案也迁移过去，实在是太麻烦了，于是考虑把博客迁移到我个人维护的课表小程序的云服务器上，但是与此同时问题也出现了。。。。

]]>
            
      
      
      
      
起因

由于服务器到期的原因，最近对Blog做了一下迁移，原本计划由腾讯云迁移到阿里云，但是发现那样的话还必须把备案也迁移过去，实在是太麻烦了，于是考虑把博客迁移到我个人维护的课表小程序的云服务器上，但是与此同时问题也出现了。。。。


问题

服务器上面有很多服务，比如课表小程序、机器人还有自己写的一些小service，所以当时采用了Nginx做端口代理分发，监听了Https的443和Http 80这两个端口，但是我的博客启动也需要监听443和80，这就导致了端口冲突，且我课表小程序的域名与我博客的域名完全不同，需要根据域名去做端口反向代理
另外由于服务比较多，而且比较庞杂（我也想过迁移服务，但是没钱买服务器啊Orz），因此需要尽可能避免修改其他服务的配置，在保持现有配置的情况下加入博客的反向代理配置
由于Nginx原有的证书与博客域名不匹配，因此需要单独为博客配置一下证书

解决方案
Nginx有一种叫做vHost的配置，可以将多个sever分在多个conf里单独配置，使用vhost可以解决我们的sever过多配置庞杂的问题
1. 创建一个conf.d的目录，在nginx.conf中添加如下配置：
include /etc/nginx/conf.d/*.conf;

2. 修改Blog端口以及配置vhost
新建一个Blog.conf在conf.d目录下,配置blog的vhost文件
server {
  listen 80;
  # 改为你的网址
  server_name com.xxx;
  # 重定向为 https
  return 301 https://xxx.xxx;

}
server {
  listen 443 ssl http2;
  # 改为你的网址
  server_name umb.ink;
  # HTTPS的证书的公私钥
  ssl_certificate xxxx/xxx/xxx;
  ssl_certificate_key xxx/xxx/xxx;

  location / {
    # 改为容器的 PORT,也就是目标sever的端口
    proxy_pass http://localhost:79;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header Upgrade $http_upgrade;
  }

}

其他的sever也可以像这样在conf.d目录下新建xxx.conf然后进行配置
3. nginx reload
nginx -s reload

之后就可以尝试访问目标sever，访问成功的话就说明配置成功了
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/1
            https://umb.ink/post/1
            Tue, 18 Oct 2022 11:52:13 GMT
            最近试着build了一个react native的android项目，血压嗯高，踩了一堆一堆的坑，得出结论，node_moudles就是一坨💩

]]>
            
      
      
      
      
最近试着build了一个react native的android项目，血压嗯高，踩了一堆一堆的坑，得出结论，node_moudles就是一坨💩

环境配置
react native是依赖于node构建的跨平台移动端框架，本质上感觉就是一个web，所以它也有node的通病，屎一样的node_moudles。。。。我参考了这几篇教程配置的环境，直接贴在下面我就不单独写了（毕竟人家的肯定比我专业一点），按教程来一点点安装即可

官方中文文档

知乎大神教程
踩坑
1. node_moudles 库依赖版本冲突,以及各种乱七八糟的问题
node_moudles内部某些库的依赖冲突的时候会报错，很难解决，，，最好的解决办法是换yarn去自动处理这些问题

更新：之后又遇到了各种个样的问题，最简单粗暴且有效的办法：
rm -rf node_moudles/
yarn install

重装node_moudles解决90%的问题（
2. macos bash_profile重启terminal不生效的问题
因为build react native 是在terminal环境下的，所以需要配置bash_profile环境变量文件，但是每次启动terminal都需要source ./bash_profile，关闭terminal以后就会失效，所以就很难受

解决办法：

在bash_profile目录下，编写zshrc文件,内容如下
yarn就好

4. gradle与java版本不适配
不得不说，gradle的版本兼容问题一直是历史大坑，当出现这样的报错时，就大概是Java版本和gradle不兼容的问题了：
技术
        
        
            
            https://umb.ink/post/2
            https://umb.ink/post/2
            Mon, 10 Oct 2022 02:21:43 GMT
            起源
最近尝试手动build wireguard- android,踩了不少坑，大概总结一下
]]>
            
      
      
      
      
起源
最近尝试手动build wireguard- android,踩了不少坑，大概总结一下

#0 环境问题
wireguard- android采用c++、go、java和kotlin进行开发，所以需要makefile和gomod的支持，这就要求我们系统中有这些环境（但是仓库的readme完全没说，屑中屑），因此首先如果要成功build wireguard，就需要先装好环境
1. NDK支持
NDK是Android中帮助我们与c/c++动态链接库进行交互的工具包，默认Android是不会单独为项目导入的，所以需要手动去引入NDK,NDK内置了makefile编译所需要的东西，不然的话无法正常编译makefile
2. sha256sum
wireguard在build时会有一个校验文件的过程，也就是distributionSha256Sum，它会调用sha256sum这条指令进行校验

这是一个Linux下用来校验文件是否合法的指令，但是macOS环境下是没有这个指令的，所以需要手动安装它的工具包


这个是直接读报错信息即可，因为AndroidStudio要求避免使用distributionSha256Sum，这样可能会导致AndroidStudio的crash（真屑啊），最好的也是最直接的解决办法就是。。。在gradle-wrapper.properties文件中把这一行属性注释掉。。。

#最后
配好了一堆环境，解决完Androidstuio的问题，这时候再点击build，就可以build success了
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/3
            https://umb.ink/post/3
            Sat, 08 Oct 2022 15:05:12 GMT
            一种提取图片边缘的算法

]]>
            
      
      
      
      
一种提取图片边缘的算法

起源
突发奇想利用边缘提取做了一个图片转线稿的小程序
先来看一下效果：

环境
Python 3.8 、PIL、numpy
直接使用pip install 安装即可
$D_{x},D_{y},D_{z}$

将三个方向的投影的值相加的和与原色相乘，也就是（灰度化）
$(D_{x}+D_{y}+D_{z})*255$


极值处理
将处理后的图像进行极值处理，RGB值靠近黑色（0）的归为黑色，靠近白色（255）的归为白色，突出边缘。


锐化处理
为了让我们最后的线稿更加清晰，可以对处理后的图片进行一定程度的锐化操作
代码


# 领域降噪
def calculate_noise_count(img_obj, w, h, width, height):
    count = 0
    for _w_ in [w - 1, w, w + 1]:
        for _h_ in [h - 1, h, h + 1]:
            if _w_ > width - 1:
                continue
            if _h_ > height - 1:
                continue
            if _w_ == w and _h_ == h:
                continue
            if img_obj[_w_, _h_] < 230:  # 这里因为是灰度图像，设置小于230为非白色
                count += 1
    return count


# 高斯滤波+锐化+领域降噪的线稿提取方案
def img_ege_get(byte: bytes):
    time = datetime.now()
    byte_stream = io.BytesIO(byte)
    im1 = Image.open(byte_stream).convert('L') # 灰度图
    im = im1.filter(ImageFilter.GaussianBlur(radius=0.75)) # 高斯模糊 75%

    a = np.asarray(im).astype('float')

    depth = 10. # 设定虚拟深度
    grad = np.gradient(a)
    grad_x, grad_y = grad
    grad_x = grad_x * depth / 100.
    grad_y = grad_y * depth / 100.
    # 梯度向量计算
    A = np.sqrt(grad_x ** 2 + grad_y ** 2 + 1.)
    uni_x = grad_x / A
    uni_y = grad_y / A
    uni_z = 1. / A
    vec_el = np.pi / 2.2
    vec_az = np.pi / 4.
    dx = np.cos(vec_el) * np.cos(vec_az)
    dy = np.cos(vec_el) * np.sin(vec_az)
    dz = np.sin(vec_el)

    b = 255 * (dx * uni_x + dy * uni_y + dz * uni_z)
    b = b.clip(0, 255)  # 二值化处理，要么为0，（黑色边缘）要么为255（白色背景）
    im2 = Image.fromarray(b.astype('uint8'))
    im2 = im2.filter(ImageFilter.SHARPEN)
    weight, height = im2.size
    # 降噪
    pim = im2.load()
    map(row_noise, [(pim, height, weight, w,) for w in range(weight)])
    imgByteArray = io.BytesIO()
    im2.save(imgByteArray, format='png')
    imgByteArray = imgByteArray.getvalue()
    print(datetime.now() - time)
    return imgByteArray

# 领域降噪
def row_noise(pim, height, weight, w):
    for h in range(height):
        if calculate_noise_count(pim, w, h, weight, height) < 4:
            pim[w, h] = 255

源码地址
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/4
            https://umb.ink/post/4
            Tue, 20 Sep 2022 07:42:54 GMT
            一嗨租车面试比较突然，也没有约面，直接电话打来开始面试，有点猝不及防，这点上体验不太好，但是另一方面来说效率真的还蛮高，两轮技术面，一轮HR面，仅仅用时两天就确认通过面试聊offer了

]]>
            
      
      
      
      
一嗨租车面试比较突然，也没有约面，直接电话打来开始面试，有点猝不及防，这点上体验不太好，但是另一方面来说效率真的还蛮高，两轮技术面，一轮HR面，仅仅用时两天就确认通过面试聊offer了

一面

自我介绍
Activity启动模式
Java 锁
高并发集合（HashMap、List）
RxJava有没有了解
Android事件分发流程
handler组成
线程池
反问

一面总共也就十来分钟，特别快，问完就撤，面试官来也匆匆去也匆匆的感觉。。。
二面
一面过了几个小时二面的电话就来了，，，和一面差不多，也是十几分钟就结束了

自我介绍
Service的理解
之前实习过程中所学到的东西
有过了解Flutter吗？
Set和List的区别
线程池有没有了解
反问

HR面

未来规划
对岗位是否感兴趣？
在实验室主要负责什么？
如何开展培训？
解答疑问，聊入职相关

]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/5
            https://umb.ink/post/5
            Sat, 15 Oct 2022 12:51:55 GMT
            今天（9.14）比心HR突然打电话约面，介于明天后天都有面试和笔试，就约在了今天晚上面试

更新，一面通过，下周二面

]]>
            
      
      
      
      
今天（9.14）比心HR突然打电话约面，介于明天后天都有面试和笔试，就约在了今天晚上面试

更新，一面通过，下周二面

一面

自我介绍
Android启动模式
Android生命周期
项目中如何实现网络请求
说一下Handler
说一下Java的锁
voilatile关键字修饰下，i++是否会产生线程冲突？
说一下在加类锁的情况下，外部访问static方法和类的对象实例访问会不会产生线程冲突？
有没有自定义View？自定义View有哪些方式？
说一下项目里遇到的难点？
线程池有了解吗？
如何在android里实现多个网络请求同步工作？
反问

二面
时隔太久了，有很多记不太清楚了

接触过哪些Android性能优化的方法？
平时如何学习？
说说项目

后续
发了offer，但是因为要实习转正，并且在上海，所以只能遗憾地拒绝了
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/6
            https://umb.ink/post/6
            Sat, 15 Oct 2022 12:52:11 GMT
            9月6号完成了360一面，目前还在流程中，后续会更新

]]>
            
      
      
      
      
9月6号完成了360一面，目前还在流程中，后续会更新

一面

自我介绍
Activity生命周期
View事件分发流程
线程和进程的区别
handler的组成
handler里一个handler可以有几个looper？
handler是如何实现线程切换的？
Android常见的内存泄漏
Android里的进程通信有哪些实现方式？
Android虚拟机和进程的区别？
如何实现自定义view？
Java锁的实现
Kotlin协程
问项目
算法题，线程交替打印
反问

面试使用的是牛客，期间频繁掉线，导致面试的时候面试官一直在频繁重连，所以整体体验一般，但是面试官很有趣，留着长发，看着很和蔼，希望能有二面
后续
挂了
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/7
            https://umb.ink/post/7
            Fri, 09 Sep 2022 13:53:41 GMT
            七月初投递百度提前批，七月底完成了一面+二面+三面+加面

之前忙于实习，一直没更，凭借记忆尽量回想一些问题更新一下。
]]>
            
      
      
      
      
七月初投递百度提前批，七月底完成了一面+二面+三面+加面
之前忙于实习，一直没更，凭借记忆尽量回想一些问题更新一下。

一面

自我介绍
Android Service的启动方式？

答：onStart、onBind
说一下MVC、MVP和MVVM的区别以及你对他们的理解？

答：巴拉巴拉，，，
了解SharedPreferences吗？知道commit和apply的区别吗？

答：同步和异步，一个是直接写硬盘一个先内存后异步写硬盘，一个有返回没返回
说一下Kotlin的高阶函数？

答：基于函数式编程思想，本质上类似Java的lambda表达式，map，filter啦之类的，，，
说一下Kotlin的协程？它与线程有什么区别？

答：协程原理，更适合轻量级的异步任务，程序层面的异步调度，，，，
了解Activity的启动模式吗？有哪几种？

答：四种，巴拉巴拉，，，，
了解Handler吗？它是干什么的？它有哪些部分组成？
一个Handler里面的Looper最多有几个？
Android如果发生了内存泄漏，有哪些可能？

答：Handler内部类，静态变量滥用，匿名内部类太多巴拉巴拉，，，
Android如果发生了ANR，有哪些可能？
介绍一下你的项目，其中有哪些难点？如何解决的？
反问

二面

自我介绍
了解Android广播机制吗？本地广播是什么？
如何优化一个ListView？

答：contentView复用，使用ViewHolder对contentView进行处理
saveInstanceState有了解吗？

答： 用在当Activity重新启动中用来保存状态并在重新OnCreate的时候恢复，存一个Bundle
Bundle是干什么的？

答：可以保存Key-Value数据，一般主要用来在Activity中进行通信
Android权限你知道有哪些？如何申请？

答：读写权限、定位权限、网络权限，，，巴拉巴拉
问项目
OKHttp了解吗？

答：只知道它使用了责任链模式
责任链模式的优缺点？

答：便于维护和拓展巴拉巴拉，，，
反问

三面
三面是部门Leader，问的更加偏向于业务思维

自我介绍
问项目
你认为什么样的广告是好的广告？（提示：可以从展示形式、持续时间来切入）

答：巴拉巴拉
了解Fragment吗？它的生命周期能不能说一下？
你在学习和研发过程中有没有遇到过很棘手的问题，如何解决的？
了解过SDK开发吗？之前在那家公司实习主要做什么工作？
有使用过SDK吗？你认为SDK和库的区别是什么？
之前对百度有了解吗？有接触过相关的业务或者使用过相关的产品吗？
反问

三面比较快，可能因为面试官有事情，前后只有半个小时不到，然后面试官跟我约了加面，让我简单找资料学一下SDK的设计原则相关的知识，他加面的时候会再问我
加面
加面比较轻松，基本就是面试官与我闲聊

你来说说现在你所了解到的关于SDK的相关知识，如何设计研发一款SDK？
你是如何学习到这些知识的？
你对日后的规划是怎样的？
考虑来实习吗？
面试官对我的评价（很不错，希望把这个offer给我，但是要看人事那边的情况）
反问

后续
隔了一个月后，百度提前批结束了，尝试联系面试官，面试官说我面试早就通过了，没有进入下一流程是因为一直需要等待提前批结束后进入排序，面试官说对我的打分并不低，但是由于学校的问题，今年人事卡双一流高校，卡的很严，会帮我准备相关的材料争取一下，但是建议我不要抱太大希望。
9.9 简历被流转，重新进入初筛阶段，百度寄摆
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/8
            https://umb.ink/post/8
            Sat, 15 Oct 2022 12:54:15 GMT
            上上周大疆一面，整体面试体验还是不错的，无奈被挂

]]>
            
      
      
      
      
上上周大疆一面，整体面试体验还是不错的，无奈被挂

一面

自我介绍
Java多线程和锁
介绍一下项目
项目里的难点，如何解决？
Kotlin的Let、Apply、Also关键字
Kotlin的扩展函数和高阶函数
Kotlin的单例是线程安全的吗？
如何设计一个线程安全的单例？
说一下你知道的设计模式
责任链模式的优缺点
说说如何理解MVC、MVP、MVVM？
Kotlin的ViewModel是如何实现数据监听的？
线程池有没有了解？
Activity四种启动模式
Activity的通信方式
Bundle原理有没有了解
本地广播和全局广播是什么？
Handler的组成和原理
Handler如何实现线程通信？
你认为Kotlin和Compose相比于传统Java有什么优势？
反问

结果
一面面试官说面试表现比较好，但是最后需要看打分排序决定是否通过，然后一面大概一周后收到了感谢信，BE
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/9
            https://umb.ink/post/9
            Sat, 15 Oct 2022 12:53:42 GMT
            上周通过Boss直聘，以部门直推的方式约到了滴滴客户端地图定位SDK开发岗位面试

一二面比较突然和急促，并且从晚上7点连续完成了一面和二面的流程，长达两个小时，问的比较多也比较累，这里简单总结一下

]]>
            
      
      
      
      
上周通过Boss直聘，以部门直推的方式约到了滴滴客户端地图定位SDK开发岗位面试

一二面比较突然和急促，并且从晚上7点连续完成了一面和二面的流程，长达两个小时，问的比较多也比较累，这里简单总结一下

一面


自我介绍
面试官介绍了一下部门的业务和技术栈
问：进程和线程的区别？进程的生命周期有没有了解

答：运行层面不同、周期不同巴拉巴拉，，，，
问：面向对象里封装、继承和多态是如何理解的？在Java和C++里分别如何实现？

答：巴拉巴拉，，，，
问：C++虚函数有没有了解？

答：没有
问：操作系统里TCP三次握手的理解，为什么不能是两次握手或者四次握手？

答：TCP原理巴拉巴拉，，，
问：操作系统里如果两个进程需要实现通信，有哪几种方式？

答：（IPC管道、内存共享、文件共享）
问：程序从代码到运行结束输出结果的过程中，发生了什么？

答：（以Java为例，构建、编译字节码、转换机器码、运行）
问：C++编译的过程相比Java有什么区别？

答：（少了编译字节码的环节，速度更快巴拉巴拉，，，）
问：对多线程有没有了解，介绍一下Java里多线程的实现方式和几种加锁的关键字

答：（Thread、Runnable、线程池、类锁、对象锁、方法锁、同步代码块、Lock）
问：有四个线程ABCD，如何使用锁实现ABCD的执行顺序？假如让ABC同时执行，D最后执行，又如何实现？
问：Java的泛型和C++泛型的区别

答：（真泛型和假泛型）
问：对操作系统虚拟内存有了解吗？
问：说一下对于已经排序好的一个集合如何对其高效查找？

答：（二分）
问：说一下对于斐波那契数列问题的两种解决算法？它们有什么特点，如何选择？

答：（递归，动态规划，巴拉巴拉，，，，）
问：说一下对于编码原则的理解

答：巴拉巴拉，，
问：思维题：五升的水杯和七升的水杯，如何操作可以得到四升的水？

答：只需要这样，再那样（挺经典的思维题，很简单），巴拉巴拉，，
问：你简历上所写的其中一个项目，在开发过程中遇到的难题以及如何解决的？
反馈：技术挺厉害的，答得都不错，稍等一会去叫二面面试官过来面Android相关


二面（都比较简单，就不写答案了）

自我介绍
问：Activity生命周期？
问：Activity之间的通信如何实现？
问：Android Service如何理解？
问：handler原理？
问：handler的looper是否可以切换线程？
问：线程池有没有了解？
问：广播机制有没有了解？
问：View的事件分发机制
问：操作系统里进程通信方式？
问：Android内存泄漏
问：Android虚拟机和进程的关系
问：强引用、弱引用、软引用和虚引用
问：C++有多少了解？
问：有没有接触过定位相关的技术？
问：有没有使用过Android内置的一些定位API？
问：Android系统架构有哪些层？每层承载了哪些功能？
问：假如让你去学习定位领域的知识与技术，在现在一无所知的情况下，大概需要多久可以熟悉业务并上手？
反问

结果
感觉整体问的比较底层和基础，更偏向于问基础知识和C++方面的知识，整体体验不错，虽然门槛较高（好像是得硕士才行，但是不知道为什么我就约到面试了），面试官是面了这么多里面相对比较和蔼的，也很幽默风趣，整体体验很棒，希望能够拿到offer
后续
HR面一直拖一直拖，每次都因为一些急事鸽了，，，搞得已经没什么信心继续面滴滴了，已经快一个月了，依然没有搞完HR面，，，随缘了
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/10
            https://umb.ink/post/10
            Thu, 08 Sep 2022 14:45:20 GMT
            起因
​		去年7月打计算机程序设计大赛的时候设计了一套互联网虚假信息监测开放平台，本来想着打完比赛就写篇博客，结果比赛越打越多，绝对不是我咕咕咕。最近投实习，暂时闲下来了，分享一下当时的一些设计思路与经验。

基本构成要素
一个开放平台以提供RPC（Remote Procedure Call）远程过程调用服务为主，应该包含以下要素：

鉴权设计（OAuth1.0、OAuth2.0）
RPC服务

平台定位
​		开放平台的定位大部分都是ToB的，因此需要精准定位客户需求，这里以我设计的互联网虚假信息监测开放平台为例。
目标群体
​		要了解客户需求，首先要明确客户到底是哪些人。
​		显而易见，需要互联网虚假信息监测服务的场景集中于各类社交平台等舆论密集的地方，因此，这种社交平台的开发者和管理者就是我们的目标群体。
痛点分析
​		确立了目标群体，那么就要分析这个群体最需要什么，即这个行业中存在的痛点在哪，从痛点着手切入，才能开发出好用的产品。
在虚假信息监测开放平台中，目标群体的痛点就在于人力审核互联网舆论的高成本、低效率，众所周知，互联网舆论是非常庞大的，要审核起来非常费劲，但是又不能完全放弃管控，你永远不知道用户会搞出什么幺蛾子。
​		因此，本平台就立足于互联网人力审核成本高、效率低这一痛点上进行构建，平台的核心是监测互联网虚假信息，平台的目标，就是让社交平台的管理人员能够提高舆论审核的工作效率，降低人力成本，将他们从无尽地审核地狱里解放出来。
结论
​		至此，我们就完成了第一步，开放平台的目标定位，接下来要做的，就是切入我们上面所分析出的行业痛点，进行平台的概要设计
概要设计
​		在这一阶段我们需要完成整体项目的结构梳理，包括架构、功能点。
需求分析
​		上面我们确立了平台需要致力于解决的痛点，那么接下来我们就需要针对痛点来推断需求，功能为需求而服务，因此基于关键痛点进行需求分析是非常重要的一个环节。
​		针对互联网舆论人力审核成本高、效率低这一痛点，我们可以拆分出多条需求。



监测多种虚假信息文本，主要包括谣言、敏感词、营销号三种


需要提供自定义化服务，以解决不同平台有不同敏感词监测规范的情况。（比如在B站，你所热爱的就是你的生活，在B站是违禁词，但在其它地方可不一定是）


需要为接入的平台提供数据可视化服务，以方便用户查看各类虚假信息的趋势，更好地制定舆论管控规则


要有容易上手的接口设计和详细的说明文档，防止用户看完一头雾水，依然不会用


稳定可靠的服务支持，毫无疑问一个社交平台的信息量是非常恐怖的，因此我们的平台必须具有极高的稳定性，要能够抗住非常恐怖的流量才可以



功能设计
​		有了明确的需求，就可以针对需求来设计功能了，我们从上面的五条需求展开来设计功能
1. 虚假信息文本监测
​		针对于虚假信息文本监测的需求，我们以提供RPC接口的方式为用户提供云端虚假信息监测服务，身份校验采用OAuth1.0原则（因为简单，现在应该使用2.0），通过签发令牌的方式来实现。
​		鉴于需要至少实现三种不同的舆论识别，也即谣言、敏感词、营销号，所以我们需要提供三套不同的RPC服务，分别就是：谣言监测、敏感词识别、营销文本分类识别。
2. 自定义舆论监测规则
​		针对部分平台需要自定义监测规则的需求来说，同样可以使用RPC接口的方式为用户提供云端服务，不同与上一点，这个功能下我们需要让用户上传自定义的文件规则。然后后台基于该数据文件，制定适合用户的识别模型。
3. 数据可视化服务
​		舆论的实时情况统计，统计用户的平台在某个时间段内的虚假信息数量，并展示给用户观看，因此需要后端实现在监测到违法信息时，对其进行一个分类统计的功能，包括在某个时间段内用户所接入平台的谣言舆论数量、带有敏感词监测的舆论数量。
]]>
            
      
      
      
      
起因
​		去年7月打计算机程序设计大赛的时候设计了一套互联网虚假信息监测开放平台，本来想着打完比赛就写篇博客，结果比赛越打越多，绝对不是我咕咕咕。最近投实习，暂时闲下来了，分享一下当时的一些设计思路与经验。

基本构成要素
一个开放平台以提供RPC（Remote Procedure Call）远程过程调用服务为主，应该包含以下要素：

鉴权设计（OAuth1.0、OAuth2.0）
RPC服务

平台定位
​		开放平台的定位大部分都是ToB的，因此需要精准定位客户需求，这里以我设计的互联网虚假信息监测开放平台为例。
目标群体
​		要了解客户需求，首先要明确客户到底是哪些人。
​		显而易见，需要互联网虚假信息监测服务的场景集中于各类社交平台等舆论密集的地方，因此，这种社交平台的开发者和管理者就是我们的目标群体。
痛点分析
​		确立了目标群体，那么就要分析这个群体最需要什么，即这个行业中存在的痛点在哪，从痛点着手切入，才能开发出好用的产品。
在虚假信息监测开放平台中，目标群体的痛点就在于人力审核互联网舆论的高成本、低效率，众所周知，互联网舆论是非常庞大的，要审核起来非常费劲，但是又不能完全放弃管控，你永远不知道用户会搞出什么幺蛾子。
​		因此，本平台就立足于互联网人力审核成本高、效率低这一痛点上进行构建，平台的核心是监测互联网虚假信息，平台的目标，就是让社交平台的管理人员能够提高舆论审核的工作效率，降低人力成本，将他们从无尽地审核地狱里解放出来。
结论
​		至此，我们就完成了第一步，开放平台的目标定位，接下来要做的，就是切入我们上面所分析出的行业痛点，进行平台的概要设计
概要设计
​		在这一阶段我们需要完成整体项目的结构梳理，包括架构、功能点。
需求分析
​		上面我们确立了平台需要致力于解决的痛点，那么接下来我们就需要针对痛点来推断需求，功能为需求而服务，因此基于关键痛点进行需求分析是非常重要的一个环节。
​		针对互联网舆论人力审核成本高、效率低这一痛点，我们可以拆分出多条需求。



监测多种虚假信息文本，主要包括谣言、敏感词、营销号三种


需要提供自定义化服务，以解决不同平台有不同敏感词监测规范的情况。（比如在B站，你所热爱的就是你的生活，在B站是违禁词，但在其它地方可不一定是）


需要为接入的平台提供数据可视化服务，以方便用户查看各类虚假信息的趋势，更好地制定舆论管控规则


要有容易上手的接口设计和详细的说明文档，防止用户看完一头雾水，依然不会用


稳定可靠的服务支持，毫无疑问一个社交平台的信息量是非常恐怖的，因此我们的平台必须具有极高的稳定性，要能够抗住非常恐怖的流量才可以



功能设计
​		有了明确的需求，就可以针对需求来设计功能了，我们从上面的五条需求展开来设计功能
1. 虚假信息文本监测
​		针对于虚假信息文本监测的需求，我们以提供RPC接口的方式为用户提供云端虚假信息监测服务，身份校验采用OAuth1.0原则（因为简单，现在应该使用2.0），通过签发令牌的方式来实现。
​		鉴于需要至少实现三种不同的舆论识别，也即谣言、敏感词、营销号，所以我们需要提供三套不同的RPC服务，分别就是：谣言监测、敏感词识别、营销文本分类识别。
2. 自定义舆论监测规则
​		针对部分平台需要自定义监测规则的需求来说，同样可以使用RPC接口的方式为用户提供云端服务，不同与上一点，这个功能下我们需要让用户上传自定义的文件规则。然后后台基于该数据文件，制定适合用户的识别模型。
3. 数据可视化服务
​		舆论的实时情况统计，统计用户的平台在某个时间段内的虚假信息数量，并展示给用户观看，因此需要后端实现在监测到违法信息时，对其进行一个分类统计的功能，包括在某个时间段内用户所接入平台的谣言舆论数量、带有敏感词监测的舆论数量。
]]>
            i@umb.ink (伞菌)
            感悟
        
        
            
            https://umb.ink/post/11
            https://umb.ink/post/11
            Thu, 08 Sep 2022 14:44:50 GMT
            问题起源
在配置gitalk评论后，会出现403报错、Netword Error和Error_Validation_Failed等问题而导致gitalk无法正常使用,这些问题多半都是因为缺乏gitalk代理导致的


查找解决办法
先前往gitalk的github仓库看有没有人提issues，一番搜寻后发现确实有不少人有这个问题，而且已经给出了可能的原因

前往博客查看接口响应情况

确实如issues所说，国内无法正常访问github的access_token，按照issues提供的解决办法，来挂个代理试试
通过和某位朋友线下py,拿到了他自己搭建的一个代理地址

或者可以去别的网站打开F12寻找他们的access_token代理地址，比如gitalk的官方网站


然后去hexo主题源目录下找到gitalk的源文件（各个主题的文件路径可能不同，但是总可以找到的）

修改gitalk对象构造器里的proxy字段（如果没有可以自己加一个）
最后编译，部署，问题便解决了
如果部署上去依然报错，那么多半是代理挂掉了，可以试试更换一个代理
]]>
            
      
      
      
      
问题起源
在配置gitalk评论后，会出现403报错、Netword Error和Error_Validation_Failed等问题而导致gitalk无法正常使用,这些问题多半都是因为缺乏gitalk代理导致的


查找解决办法
先前往gitalk的github仓库看有没有人提issues，一番搜寻后发现确实有不少人有这个问题，而且已经给出了可能的原因

前往博客查看接口响应情况

确实如issues所说，国内无法正常访问github的access_token，按照issues提供的解决办法，来挂个代理试试
通过和某位朋友线下py,拿到了他自己搭建的一个代理地址

或者可以去别的网站打开F12寻找他们的access_token代理地址，比如gitalk的官方网站


然后去hexo主题源目录下找到gitalk的源文件（各个主题的文件路径可能不同，但是总可以找到的）

修改gitalk对象构造器里的proxy字段（如果没有可以自己加一个）
最后编译，部署，问题便解决了
如果部署上去依然报错，那么多半是代理挂掉了，可以试试更换一个代理
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/12
            https://umb.ink/post/12
            Sat, 08 Oct 2022 14:58:15 GMT
            起因
搭建好了个人博客，为了能够与沙雕网友在博客里愉快吹逼，需要开一个评论
]]>
            
      
      
      
      
起因
搭建好了个人博客，为了能够与沙雕网友在博客里愉快吹逼，需要开一个评论

步骤
这里选用使用人数最多的gitalk
1. npm安装
点这里创建



字段说明：
​	Application name：应用名称,叫啥都行，可以叫BlogTalk方便区分
​	Homepage URL：你的博客的链接，如果没有配域名的话就是https://<githubname>.github.io
​	Application description: 应用描述，随便写
​	Authorization callback URL:  验证回调地址，同HomePageURL

3. 查看clientID和clientSecret
到Github首页，点击个人头像->settings->Developer settings->OAuth Apps->刚才创建的应用


如图就是ClientID，点击Generate a new client secret可查看Client secrets

4. 创建一个github仓库用来存储评论
随便新建一个仓库，注意设为Public即可
5. 配置

找到博客主体的配置文件中关于gitalk的配置（如果博客没有可以参考官方文档，自己魔改一番）（如果不想改，建议换主题）
由此，gitalk便配置完成了，编译部署之后即可查看效果
番外：配置代理
在某些情况下可能会出现gitalk无法正常工作，报403、Netword Error等情况，这些情况只需要配置一个代理即可，解决方法可以参考另一篇文章
]]>
            i@umb.ink (伞菌)
            技术
        
        
            
            https://umb.ink/post/13
            https://umb.ink/post/13
            Sat, 08 Oct 2022 15:00:51 GMT
            使用Hexo+Github Page快速搭建个人博客

]]>
            
      
      
      
      
使用Hexo+Github Page快速搭建个人博客

注意：本博客仅仅针对纯小白，快速搭建一个能用的博客
环境搭建


安装NodeJS(建议使用 Node.js 12.0 及以上版本)


安装Git（参考廖雪峰git教程）


注册一个Github账号


登录Github


在GitHub上新建一个仓库


如图，点击New repository，在Repository name 的位置填写域名，格式是 username.github.io.
比如你的github名字是farewell12345，那么这里就写farewell12345.github.io



填完以后可以啥都不用选，拉到最下面点击Create repository
创建成功之后，进入仓库，点击右上角的 Settings



找到 GitHub Pages 选项，选择一个 GitHub 官方提供的主题



主题随便选一个，选择完毕后在跳转界面点击Commit changes，就完成了Github Page的配置
这时可以试着访问一下 https://username.github.io   （就是刚才在Repository name 的位置填写的域名），如果正常打开了页面，就说明配置成功了。




选择一个空文件夹，打开Bash窗口（装好Git以后右键菜单中自带），使用npm安装Hexo

cd Blog
npm install
hexo g
hexo s


hexo s输入完毕后，不要关闭Bash窗口,就保持这样的状态，然后进入浏览器，输入http://localhost:4000，去尝试访问这个地址，如果访问到了页面，说明本地Hexo 环境已经搭建好了




开始搭建属于自己的博客

到Hexo主题网站（点击蓝字即可）找一个你最顺眼的主题，点进去，找到它的使用手册，因为不同的主题其说明文档也不一样，所以在配置主题的过程中就需要自己去踩坑了。这里以我目前在用的Nexmoe主题为例：
从Hexo主题网站找到它以后，点击进入它的Github仓库，点击Code，然后download zip（如果配置了Git SSH Key可以选择直接clone），下载主题。



打开你电脑上之前用Hexo生成的Blog文件夹,进入themes文件夹中，把刚才下载好的主题zip解压并放入这个themes文件夹下


​			

打开blog目录下的config.yml配置文件，修改theme为主题文件夹的名字，比如：



在config.yml中修改博客名和描述等信息




author:作者
title：你博客标题（名字）
description：博客描述
url：设置你博客的域名（就刚才在Github上设置的那个）
config基础设置这样就可以了，其他如果想了解的话可以去Hexo官方文档


返回主题仓库查看Readme



查看主题的教程，对主题进行自定义配置
打开主题文件夹


打开这个目录下的config.yml，对照主题官方文档进行自定义配置
（因为每个人选择的主题不一样，所以这里就不多赘述了，一般主题的官方文档是写得很详细的）
运行博客
在Blog根目录下运行Bash窗口，输入
"提交的描述"
git push origin master

这里需要获取你的博客在github上的链接，打开博客对应的github仓库，点击code，

这个就是仓库的链接
push成功以后，等一会去查看github仓库是否有了我们push上去的东西，如果有，那就可以去试着访问https://username.github.io（就是刚才在Repository name 的位置填写的域名）了，如果出现了界面，那就说明博客成功了

如果配置的过程中遇到未知错误，请记住搜索引擎是个好东西（
]]>
            i@umb.ink (伞菌)
            技术