前言

上一篇《外行转码农，焦虑到躺平》分享我的从业经历收到大家很多关注，这里继续分享一下我的生活

我是16毕业在厂里干了两年，18年7月转行前端开发。在后面4年，也就是18～22年是很投入的，这几年上完班回到家基本也在学习，学技术考证，可谓说没有自己的生活，这几年是我技术进步最快的几年，也是很快乐的几年，大家懂得全身投入做一件事的快乐吧。

近几年，感觉自己很难突破自己的瓶颈了，慢慢将重心转为生活。也要声明一下，这两年我可不是完全躺平，对应工作我还是很负责的去做，只是工作不是我的全部了。分享一下这几年的收获吧

近几年收获

2019

• 中级软件设计师

2020

• 基金从业


• 证券从业

2021

• pmp


• 彩铅绘画

2022

• 计算机专业课程系统学习


• 背了5000单词

2023

• 算法 150道


• 浅浅玩了区块链技术、android、ios开发


• 中级经济师

2024

• 缝纫


• 计划考 中级会计

看书

我之前基本不怎么看书的，后面慢慢与书籍成为了朋友。这几年读了上百本书，主要涉及：哲学、心理学、经济学、文学、历史、政治。这些可是我之前不怎么关注的，曾经的我很封闭，对全球地理概念都不清楚那种。老爸也说我现在知识面扩展了很多。

醒悟

感觉28岁是我的醒悟元年，告别过往原谅也放过自己，生活从新开始吧。

之前的我，对于朋友没有秘密，很依赖别人，后面慢慢懂得自己的痛苦只能自己慢慢消化，我学会了用 “行为认知疗法”治愈自己，很推荐大家去了解。

分享

我把这些放到b站了，大概感兴趣可以去看哦,搜索 liucheng58

读书笔记

最近不开心看的两本书

-《蛤蟆先生去看心理医生》

“PLOM代表了四个英文单词，意思就是‘可怜弱小的我呀’。这个游戏你每局都赢了，也可以说是输了，这取决于你自己的看法。”

把我们的人生当作一次游戏，跳出自我，静静俯视它的发展。个人在这场游戏中，可能就是游戏背景中一颗小小草，在画面中一闪而过，没有人注意到它刚被怪兽踩了一脚。
而自我的人一直盯着想着那颗小草，而忽略了整个游戏的乐趣。世界上有很多有趣的事情，不要总是计较一时的得失——致自己。

“‘成人自我状态’指我们用理性而不是情绪化的方式来行事。它让我们能应对此时此地正在发生的现实状况。”苍鹭回答。“‘成人自我状态’指我们用理性而不是情绪化的方式来行事。它让我们能应对此时此地正在发生的现实状况。”苍鹭回答。

我这两年最大的三个变化

1、遇事不发脾气，冷静思考当下如何解决；

2、如果没法推脱，就怀着快乐的心态去做吧，和那个任性的小孩好好商量，讲解做这件事的好处，不要抱怨的把事情做了，费力不讨好；

3、聆听他人，角度不同想法不同，没有谁对谁错。

-《幸福之路》

一个人应该认真建立自己的意念，让它与理性相信的方向一致，不要让任何非理性的信仰不经过检视就占据自己的心灵。

回头看老一辈很多坚信的观念我们都无法接受，这就是他们小时候接受到的信息刺激。一个人改变自己的观念很难，改变既有的思维模式很难，但是如果能打破它们，我们就是放过了自己。之前看到做法就是每日自检，找出困扰你的想法，分解并破解。

史铁生说他只能躺在床上的时候他无比怀念坐轮椅的时候，只有体验人生角色的酸痛苦辣，才能做到感同身受，仅仅看书冥想很多东西无法吸收，我想这也是成佛要经历81难吧

一个把注意力转向自我内心的人，会找不到任何值得关注的事；而那些对外界事物兴致勃勃的人，当他偶尔把注意力转移到自己的灵魂，他会发现所有以前采集、累积的各式各样有趣的材料，都已经被转换重组成美丽且有价值的东西

我的理解是：不要太在乎一时的得失、不要经常悔恨自己的错误，其实命运早已注定。我们应该跳出对自身的注视，面临抉择充分收集信息，然后一条路走到黑，然后让它自由发展。其他时候我的精力要跳出自身，去体验大好河山，体验先人深邃精神。

所有需要技巧的工作都有带给人乐趣的共性，只要这技巧有价值和无限的进步空间

就像程序员很多人最开始是喜欢而从事，写代码是个建设的过程，看着代码运行成一个个应用。但是工作3-5年后，很熟练了，很难有进步空间，很多人就怠慢了。最重要的是很多人意识到，再牛赚的钱也是很有限的。

缝纫

最近朋友圈分享自己第一件缝纫作品 ，收到朋友很多赞赏，我感觉我有点飘了。这里我再分享一次

绘画

我五音不全，但是很喜欢绘画，21年报了个兴趣班，画了一些彩铅，这两年没画了。

买了平板、画笔和procreate软件，后面打算学习一下平板绘画，感觉还是电子的容易保存。后面如果开动了，再分享我的成果。

猫猫

2020年5月养了第一只中华田园猫，后面养过5只中华田园猫：莞莞、果果、蕉蕉；救助过两只流浪猫：小黄、小白；

小黄是在地下车库别人车底，小白是在公园草丛，两只猫猫都是连续叫了好几天，又怕人那种小猫；后面我蹲了几小时，用捕猫笼给抓住的；它们都是又瘦又脏，养肥了洗了澡，教了它们使用猫砂，后面给它们找了人家。

做饭

我现在每天都自己带饭，我做饭的效率很高，周末将肉切好，炒两个菜一般半小时可以搞定。

面食

买了蒸锅、烤箱、电饼铛，做了包子、面包和饼饼，这些也是我很爱吃的

最后

我的人生有很多遗憾，遗憾成熟太晚、遗憾高考失利没复读，但是现在也放下了，我总要体会我人生角色的起起伏伏，痛苦使我成长。

我的执行力还是差了点，很多想做的都搁置了。自己习惯依赖，随波逐流，总希望别人给自己人生一个规划，这几年也是一个去依赖的过程。

我之前对自己要求很高，现在功利心下降了，做的事情都是随性而行，才发现自己兴趣很多。

我买了中国三维地图和世界三维地图，曾经很想抛开现有的去外面看看，我爸说我幼稚不成熟，这几年这个想法也放弃了，不知道是成熟了还是向生活妥协了。

接下来，我希望自己用一个平静的心态度过此生，不以物喜不以己悲。

希望被大家温柔以待，不要中伤我。

下一篇《2024转行前端第6年》展示我躺平后捣鼓的东西

介绍自己

本人女，16年本科毕业，学的机械自动化专业，和大部分人一样，选专业的时候是拍大腿决定的。

恍恍惚惚度过大学四年，考研时心比天高选了本专业top5学校，考研失败，又不愿调剂，然后就参加校招大军。可能外貌+绩点优势，很顺利拿到了很多工厂offer，然后欢欢喜喜拖箱带桶进厂。

每天两点一线生活，住宿吃饭娱乐全在厂区，工资很低但是也没啥消费，住宿吃饭免费、四套厂服覆盖春夏秋冬。

我的岗位是 inplan软件维护 岗位，属于生产资料处理部门，在我来之前6年该岗位一直只有我师傅一个人，岗位主要是二次开发一款外购的软件，软件提供的api是基于perl语言，现在很少有人听过这个perl吧。该岗位可能是无数人眼里的神仙岗位吧，我在这呆了快两年，硬是没写过一段代码...

inplan软件维护 岗位的诞生就是我的师傅开创的，他原本只是负责生产资料处理，当大家只顾着用软件时，他翻到了说明书上的API一栏，然后写了一段代码，将大家每日手工一顿操作的事情用一个脚本解决了，此后更是停不下来，将部门各种excel数据处理也写成了脚本，引起了部门经理的注意，然后就设定了该岗位。

然而，将我一个对部门工作都不了解的新人丢在这个岗位，可想我的迷茫。开始半年师傅给我一本厚厚的《perl入门到精通》英文书籍，让我先学会 perl 语言。（ps：当时公司网络不连外网，而我也没有上网查资料的习惯，甚至那时候对电脑操作都不熟练...泪目）

师傅还是心地很善良很单纯的人，他隔一段时间会检查我的学习进度，然而当他激情澎拜给我讲着代码时，我竟控制不住打起了瞌睡，然后他就不管我了～～此后我便成了部门透明人物，要是一直透明下去就好了。我懒散的工作态度引起了部门主管的关注，于是我成了他重点关注的对象，我的工位更是移到了他身后～～这便是我的噩梦，一不小心神游时，主管的脸不知啥时凑到了我的电脑屏幕上～～～😱

偶然发现我的师傅在学习 php+html+css+js，他打算给部门构建一个网站，传统的脚本语言还是太简陋了。我在网上翻到了 w3scool离线文档 ，这一下子打开了我的 代码人生。后面我的师傅跳槽了，我在厂里呆了两年觉得什么都没学到，也考虑跳槽了。

后面的经历也很魔幻，误打误撞成为了一名前端开发工程师。此时是2018年，算是前端的鼎盛之年吧，各种新框架 vue/react/angular 都火起来了，各种网站/手机端应用如雨后春笋。我的前端之路还算顺利吧，下面讲讲我的经验吧

如何入门

对于外行转码农还是有一定成本的，省心的方式就是报班吧，但是个人觉得不省钱呀。培训班快则3个月，多的几年，不仅要交上万的培训费用，这段时间0收入，对于家境一般的同学，个人不建议报班。

但是现在市场环境不好，企业对你的容忍度不像之前那么高。之前几年行业缺人，身边很多只懂皮毛的人都可以进入，很多人在岗位半年也只能写出简单的页面，逻辑复杂一点就搞不定～～即使被裁了，也可以快速找到下家。这样的日子应该一去不复返了，所以我们还是要具备的实力，企业不是做慈善的，我们入职后还是要对的起自己的一份工资。

讲讲具体怎么入门吧

看视频：

b站上有很多很多免费的视频，空闲之余少刷点段子，去看看这些视频。不要问我看哪个，点击量大的就进去看看，看看过来人的经验，看看对这个行业的介绍。提高你的信息量，普通人的差距最大就在信息量的多少

还是看视频：

找一个系统的课程，系统的学习 html+css+js+vue/react，我们要动手写一些demo出来。可以找一些优秀的项目，自己先根据它的效果自己实现，但后对着源码看看自己的局限，去提升。

做笔记：

对于新人来说，就是看了视频感觉自己会了，但是写起来很是费力。为啥呢？因为你不知道也记不住有哪些api，所以我们在看视频学习中，有不知道的语法就记下来。

我之前的经验就是手动抄写，最初几年抄了8个笔记本，但是后面觉得不是很方便，因为笔记没有归纳，后续整理笔记困难，所以我们完全可以用电子档的形式，这方便后面的归纳修改。

回顾：

我们的笔记做了就要经常的翻阅，温故而知新，经常翻阅我们的笔记，经常去总结，突然有一天你的思维就上升了一个高度。

• 慢慢你发现写代码就是不停调用api的过程


• 慢慢你会发现程序里的美感，一个设计模式、一种新思维。我身边很多人都曾经深深沉迷过写代码，那种成就感带来的心流，这是物质享受带来不了的

输出：

就是写文章啦，写文章让我们总结回顾知识点，发现知识的盲区，在这个过程中进行了深度思考。更重要的是，对于不严谨的同学来说，研究一个知识点很容易浅尝则止，写文章驱动自己去更深层系统挖掘。不管对于刚入行的还是资深人士，我觉得输出都是很重要的。

持续提升

先谈谈学历歧视吧，现在很多大厂招聘基本条件就是211、985，对此很是无奈，但是我内心还是认可这种要求的，我对身边的本科985是由衷的佩服的。我觉得他们高考能考上985，身上都是有过人之处的，学习能力差不了。

见过很多工作多年的程序员，但是他们的编码能力无法描述，不管是逻辑能力、代码习惯、责任感都是很差的，写代码完全是应付式的，他们开发的代码如同屎山。额，但是我们也不要一味贬低他人，后面我也学会了尊重每一个人，每个人擅长的东西不一样，他可能不擅长写代码，但是可能他乐观的心态是很多人不及的、可能他十分擅长交际...

但是可能的话，我们还是要不断提高代码素养

• 广度：我们实践中，很多场景没遇到，但是我们要提前去了解，不要等需要用、出了问题才去研究。我们要具备一定的知识面覆盖，机会是给有准备的人的。


• 深度：对于现在面试动不动问源码的情况，很多人是深恶痛绝的，曾经我也是，但是当我沉下心去研究的时候，才发现这是有道理的。阅读源码不仅挺高知识的广度，更多让我们了解代码的美感

具体咋做呢，我觉得几下几点吧。（ps:我自己也做的不好，道理都懂，很难做到优秀呀～～～）

• 扩展广度：抽空多看看别人的文章，留意行业前沿技术。对于我们前端同学，我觉得对整个web开发的架构都要了解，后端同学的mvc/高并发/数据库调优啥的，运维同学的服务器/容器/流水线啥的都要有一定的了解，这样可以方便的与他们协作


• 提升深度：首先半路出家的同学，前几年不要松懈，计算机相关知识《操作系统》《计算机网络》《计算机组成原理》《数据结构》《编译原理》还是要恶补一下，这是最基础的。然后我们列出自己想要深入研究的知识点，比如vue/react源码、编译器、低代码、前端调试啥啥的，然后就沉下心去研究吧。

职业规划

现在整个大环境不好了，程序员行业亦是如此，身边很多人曾经的模式就是不停的卷，卷去大厂，跳一跳年薪涨50%不是梦，然而现在不同了。寒风凌凌，大家只想保住自己的饭碗（ps：不同层次情况不同呀，很多大厂的同学身边的同事还是整天打了鸡血一般）

曾经我满心只有工作，不停的卷，背面经刷算法。22年下半年市场明显冷下来，大厂面试机会都没有了，年过30，对大厂的执念慢慢放下。

我慢慢承认并接受了自己的平庸，然后慢慢意识到，工作只是生活的一部分。不一定要担任ceo，才算走上人生巅峰。最近几年，我爱上了读书，以前只觉得学理工科还是实用的，后面慢慢发现每个行业有它的美感～

最后引用最近的读书笔记结尾吧，大家好好体会一下论语的“知天命”一词，想通了就不容易焦虑了～～～

自由就是 坦然面对生活，看清了世界的真相依然热爱生活。宠辱不惊，闲看庭前花开花落。去留无意，漫随天外云卷云舒。

开篇

大家好，我是聪。想必对于很多初入职场，心中怀着无限激情的兄弟们，对于接手老代码都会有很多愤慨，碰到同事的代码十分丑陋应不应该改！我也是这样，我相信有很多人同样有跟我一样的经历。满打满算实习 + 正式工作，我也敲了两年多代码，我今天来说说我自己的看法吧。

亲身经历

我第一次接手老代码的时候，映入我眼帘的就是侧边栏满页的黄色提示以及代码下面的众多黄色波浪线，以及提交代码时的提示，如下图：

我内心 OS：

1）大干一场，把黄色波浪线全干掉！

2）同事这写的也太不优雅了吧，改成我这样！

3）这代码怎么也没格式化，我来 Ctrl + Alt + L 格式化一波！

已老实，求放过

干掉黄色波浪线，将代码改 ”优雅“ 结局如下：

1）不声不吭动了同事代码，换来同事怒骂，毕竟人家逻辑写好，然后你按你想法来搞，也没有跟人家商量。

2）后续领导找你加需求，你发现原来之前的代码有妙用，你悔不当初，被扣绩效。

3）格式化后，在项目修改记录上面是你的修改，这代码出问题，负责人先来找你。

说说我的看法

代码能跑不要动

前几日我要在老项目中，新增一点小功能，在新增完功能后，我扫了一眼代码，发现有几处逻辑根本不会执行，比如：抛异常后，执行删除操作类似，我也不会去义愤填膺的去干掉这块代码，毕竟我想到一点！项目都跑七八年没出问题了，能跑就别动它。

代码强迫症不要强加于别人

前几日在某金看见了这样一个沸点：

这样的事情其实在小公司经常发生，你觉得它写的不优雅，封装少，可能是别人也有别人的难处，至少不能将自己想法强加于别人，比如领导突然来一个需求，跟你说今天你得完成，然后第二天这个需求，你要这样改、再给我加点新需求上去，你能想到的封装其实只是你冷静下来，而且没有近乎疯狂的迭代需求得到的想法，当你每天都要在原代码上面疯狂按照领导要求修改，可能你会有自己的看法。

新增代码，尽量不影响以前逻辑

新增代码的时候，尽量按照以前的规则逻辑来进行，比如我改的一个老项目，使用的公司自己写的一套 SQL 处理逻辑，我总不能说不行！我用不惯这个！我要用 MyBatis！！！！那真的直接被 T 出门口了。

尊重他人代码风格

每个人的代码风格都有所不同，这个很正常，不同厨师的老师教法不一样，做出的味道还不一样呢，没有最好的代码，只有更适合的代码，刚好我就有这样的例子：

我注入 Spring 依赖喜欢用构造注入、用 Lombook 的注解 @RequiredArgsConstructor 注入，我同事喜欢 @Autowired ，我能说他不准用这个吗，这个是人家的习惯，虽然 Spring 也不推荐使用这个，但改不改这个都不会影响公司收益，反而能少一件事情，促进同事友好关系，哈哈哈哈，我是这样认为的。

处理好同事之间的关系

哈哈哈哈这个真的就是人情事故了，你换位想象一下，如果你写的幸幸苦苦的代码，新来的同事或者实习生，来批评你的代码不规范，要 Diss 你，偷偷改你代码，就算他说的超级对，你心里都十分不好受，会想一万个理由去反驳。

我一般如果需求需要改动同事的代码，我会先虚心的向同事请求，xx哥，我这个需求要改动你这边的代码来配合一下，你来帮我一起看看，你这部分的代码这样改合理吗，或者你自己改下你自己的部分，然后我合并一下~ 谢谢 xx哥。

最后

希望大家都能遇到与自己志同道合的同事一起快乐的开发~，我经历的可能没有大家伙的多，大家如果还碰见因为改老代码发生的惨案，欢迎大家一起来分享，我也来跟大佬们学习一下~

这几天有个同事离职了，本来那是last day，还有半个小时，但他还在那里勤勤恳恳的写着代码。我很好奇，就问：老张，你咋还不做好准备，都要撤了，还奋笔疾书呐。他说：等会儿和你说。

等了半个小时，他说：走，一起下班。我跟你说个好东西。

我说：好的。

老张一边走一边跟我说：公司的下载大文件代码不好。

我说哪里不好了，不是都用了很久了。

他说，那些代码，每次项目需要的时候，还得拷过来拷过去的，有时候拷着拷着就拷丢了，还得去网上现找代码，很不好。

我问：那然后呢？

他说：我这两天把这段代码封装了一下，封装成了npm包。以后，大家就直接调用就可以了，不用重复造轮子，或者担心轮子走丢了。我说那太好了。

他说：我把这个npm包给你，以后你就说自己写的，下个季度晋升的时候，你就说，为公司解决了代码冗余，重复造轮子的问题，而且让下载大文件功能更加便捷，节省开发时间，提升了开发效率。

我说：那怎么好啊，得请你吃个饭啊，你都要走了。不过，你先跟我说说，怎么用这个npm包啊。

下载大文件版

比如我们现有的成形的项目，大家使用axios或者fetch，一定在项目里已经封装好了请求，所以直接调用服务端给的请求地址，获取到blob数据流信息就可以了。但是拿到blob数据流以后，这段代码得四处拷贝，重复造轮子，很不好。所以可以这样使用，高效、便捷。

下载js-tool-big-box工具包

执行安装命令

npm install js-tool-big-box

项目中引入ajaxBox对象，下载文件的公共方法，downFile 在这个对象下面。

import { ajaxBox } from 'js-tool-big-box';

调用实现下载

比如你在项目中已经封装好了axios或者fetch的实现，那么只需要正常发送请求，然后调用方法即可，使用非常方便。

fetch('https://test.aaa.com/getPDF').then(res => res.blob()).then((blob) => {

    ajaxBox.downFile(blob, '优乐的美.pdf');

});

在这个方法中，你只要将接口返回的信息流转为blob流，然后传入 downFile 方法中，然后再传入一个参数做为下载后的文件名即可。

fetch请求 + 下载实现版本

我又问他，的确是很多项目里，请求都已经封装好了。但我之前做过一个项目，功能很简单，大部分都是展示类的。但产品在一个详情页，让我加下载功能，我的请求并没有做封装。

然后呢，服务端告诉我，这个下载文件的接口，还需要传入参数params，需要传入headers，你这个方法就不适用了吧？

他想了一下，说。也是可以的，你听我说啊。

定义请求参数们

const url = 'https://test.aaaa.com/getPDF';

const headers = {

    'Content-Type':'application/x-www-form-urlencoded;charset=UTF-8',

    'CCC-DDD': 'js-tool-big-box-demo-header'

}

const params = {

    name: '经海路大白狗',

    startDate: '2024-03-05',

    endDate: '2024-04-05',

}

你看这些参数了吗？url就是下载文件需要的那个接口，如果是get请求呢，你就按照get形式把参数拼接上去，如果是post形式呢，你就需要后面的这个params变量做为入参数据。如果服务端需要headers呢，你就再将headers定义好，准备往过传。

调用实现

ajaxBox.downFileFetch(url, '相的约奶的茶.mp4', 'get', headers, dataParams);

你看到这个 downFileFetch 方法了吧，他也在 ajaxBox 对象下面。

第一个参数呢，表示服务端接口，如果是get请求呢，就把参数拼接上去；

第二个参数呢，表示下载后文件名，比如 down.pdf 这样；

第三个参数呢，默认是get请求，如果不想写get呢，你就写个null，但是你得写进去，如果服务端要求是个post请求呢，你就写post；
第四个参数呢，就是headers啦，服务端需要你就传过去，不需要你就写个null；
第五个参数呢，如果是psot请求，你就传入json对象过去，如果没有参数，你就不写也行，写个null也行。

我说：你这个工具库真是棒，js-tool-big-box，就是前端JS的一个大盒子啊。他说：是的，里面还有很多特别实用的方法，用了这个工具库后，前端项目可以少些很多公共方法，少引很多第三方库，很不错的。我也要离职了，你在公司就说这是你开发的。

我说：那我得请你吃饭啊。于是，我去买了一瓶茅台王子酒，花了260元，定了两份炒饼，花了30元。

等吃完，我说，你这个工具库可以啊，直接从我这里挣了290元。

他说：看你说的，酒你喝了一半，炒饼你吃了一份。我这顶多也就是145元啊。

看完不过瘾？这里有更全的js-tool-big-box使用指南哦，掘金链接直达(只会Vue的我，一入职就让用React，用了这个工具库，我依然高效 - 掘金 (juejin.cn))

最后告诉你个消息：
js-tool-big-box的npm地址是(js-tool-big-box 的npm地址)

js-tool-big-box的git仓库地址(js-tool-big-box的代码仓库地址)

哈喽大家好，我是大圣，正如标题所说，我离开北京了

视频链接

今天来聊一下我在北京的这17年，北京好在哪，以及为什么要选择离开， 以及下一步的打算
想
提前声明，我下面会说一些北京和英国的优点，我个人只在英国生活的一个月，我体验到的优点肯定非常片面，也欢迎评论区讨论

离开北京的当天我还兴致勃勃的拿着gopro 准备拍个视频，但是下了楼看到北京天，突然很感慨，没了拍视频的兴致，拍几个照留个纪念吧

北京好在哪

我2007年来北京念书，咱们国家排名前50的那200所高校之一，我们家家庭条件不是特别好，但是北京让我开了眼界

我来自一个国家级贫困县，我跟我哥俩人上大学比较费钱，到我大学毕业那天起，我们家外面还欠着外债，经济虽然窘迫，但是我也感受到了后海步行街的灯红酒绿，鸟巢水立方世界级赛事，毕业之后互联网黄金时代的革命，也正是北京各地的创业咖啡厅里，很多投资人和创业者激情的演讲，让我接触到软件编程，成就了现在的我

可以说一线城市虽然压力很大，但还是给了普通人很多的机会，如果我毕业就在我们老家那边阜阳，或者努努力去省会合肥，生活应该也很棒，我可能就不会有现在这么多选择

北京很好，我在这里工作，学习编程，创业，我33岁的时候好像完成了人生第一阶段的任务，在北京有房有车，我媳妇有北京户口，看起来养娃也没什么问题，那为什么要离开呢

两个原因吧，养娃和个人职业实现

从我媳妇查出来怀孕的那天，我兴奋了一整天，但是到了晚上就开始和媳妇讨论，怎么让他成为一个快乐的孩子，讨论了俩星期吧

我其实已经卷出来了，但是我不想让孩子也走这条路，我觉得比较辛苦，他现在还只是一个胚胎，后面的中高考，考研考公，面试，裁员等等，有没有什么事情能让他快乐一些，以后大学报志愿的时候，也不会只看就业率如何来选择，讨论来 讨论去，最后冒出一个新想法，要不出国试试，都说老外快乐教育

第二个就是我跟媳妇个人的价值实现，我媳妇是低我三届的学妹，我俩处对象那会他还在读研，她学设计的，腾讯当产品经理实习生，为了北京户口去了国企，算是为家庭做了一些贡献，我感觉国企的工作稍显琐碎一些

我在的互联网行业，很刺激很好玩，很严重的35岁裁员危机，最近大家也能看到很多新闻，工资确实高，裁员也猛

我们都希望能有一个有趣的，持久的职业生涯，能够有大量的时间，去学习怎么成为一个合格的父母，少赚一些可以的，但是离开北京，国内的城市好像很难实现

而且我跟我媳妇一直都有一个环游世界的梦想，只是一只没机会实现，所以，出国这两个字 就在我们家出现了

为什么选英国

首先基本大家都有点英语基础，但是学起来很难受，所以真的不想学二外，并且咱们普通人，基本投资移民和咱们也没啥关系，不花钱的工签就是性价比最高的

所以符合这个要求的，能找到程序员工作的美国，新加坡，加拿大，澳洲，英国，新西兰，和一些欧洲的国家

然后不想努力奋斗了，排除了美国和新加坡

支持远程工作，不卷，最好时区和国内有重合，我国内的卖课服务可以继续

当然准备去后，英国有一些优点我觉得可以参考，可能其他国家也有 欢迎补充

不过以上都不是硬性条件，比如美国，加拿大澳大利亚我也会看机会，我也会考虑去奋斗，整体比较随缘， 我之前也分享过一些学英语的内容，然后给英国这边remote了半年后，问了下工签政策，元旦那会就担保过来了，然后体验了一个月，觉得还能接受，然后回国 准备搬家的事

打算

英国当然也有特别多的缺点，比如我一个朋友就因为税务和天气问题，准备去新加坡，也有一个因为职业发展问题准备去北美奋斗，也同时有朋友努力学英语去澳洲，和从澳洲努力准备回国

都是个人选择，主要就是你想过什么样的生活

英国吃的也不咋地，我也不太喜欢这边的酒吧文化，也没有国内安全，所以我也在探索

我在英国还是remote，所以暂时就在伦敦和周边生活，反正5年后拿绿卡，后面需要很努力的带娃，花大量的时间生活，旅游，比如在欧洲多玩一玩

同时继续发展卖课视野，做一个好的讲师，研发远程，或者web3的开发课程，除了国内也开辟一下欧洲市场

伦敦这边公园特别多，我住的两个地方周边溜达十分钟，都有草坪非常好的公园，非常适合遛娃和遛狗

而且也很适合养狗，狗可以坐地铁，火车，非常方便

我家孩子也一岁了，我希望以后我能成为一个合格的父亲把，能够陪他成长，在我的能力范围内，给他多一些选择，多快乐一些

找一些能持续成长的爱好，能够和孩子一起成长，比如踢球网球，重新开始打dota2，黑悟空也准备配个电脑好好玩，回归生活

下一期聊一下英国这边的生活体验，成本啥的吧，开心工作，努力生活
视频版

背景

长话短说，就是在2022年6月的时候加入了一家很小创业公司。老板不太懂技术，也不太懂管理，靠着一腔热血加上对实体运输行业的了解，加上盲目的自信，贸然开始创业，后期经营困难，最终散伙。

自己当时也是不察，贸然加入，后边公司经营困难，连最后几个月的工资都没给发。

当时老板的要求就是尽力降低人力成本，尽快的开发出来App(Android+IOS)，老板需要尽快的运营起来。

初期的技术选型

当时就自己加上一个刚毕业的纯前端开发以及一个前面招聘的ui，连个人事、测试都没有。

结合公司的需求与自己的技术经验(主要是前端和nodejs的经验)，选择使用如下的方案：

也就是初期选择使用egg.js + MySQL + uni-app + antd-vue，来开发两个App和一个运营后台，快速解决0到1的问题。

关于App开发技术方案的选择

App的开发方案有很多，比如纯原生、flutter、uniapp、react-native/taro等，这里就当是的情况做一下选择。

为什么选择egg.js做后端

很多时候方案的选择并不能只从技术方面考虑，当是只能选择成本最低的，当时的情况是egg.js完全能满足。

中间的各种折腾

前期开发还算顺利，在规定的时间内，完成了开发、测试、上线。但是，老板并没有如前面说的，很快运营，很快就盈利，运营的开展非常缓慢。中间还经历了各种折腾的事情。

反正就是不断提出要修改产品、设计、和代码。中间经过不断的讨论，摆出自己的意见，好在最终技术方案没修改，前期的工作成果还在。后边加了一些新的需求：系统升级1.1、ui升级2.0、开发小程序版本、开发新的配套系统(小程序版本)以及开发相关的后台、添加即时通信服务、以及各种小的功能开发与升级；

中间老板要加快进度了就让招人，然后又无缘无故的要开人，就让人很无奈。最大的运营问题，始终没什么进展，明显的问题并不在产品这块，但是在这里不断的折腾这群开发，也真是难受。

明明你已经很努力的协调各种事情、站在公司的角度考虑、努力写代码，却仍然无济于事。

后期技术方案的调整

人员招聘，团队的管理

人员招聘

如下是对于当时的人员招聘的一些感受：

团队管理

对于小团队的管理的一些个人理解：

最后总结及选择创业公司避坑建议!important

起因

在最近鸿蒙各种新闻资讯说要鸿蒙不再兼容android之后，我看完了鸿蒙视频，并简单的撸了一个demo。

• # 鸿蒙HarmonyOS从零实现类微信app效果第一篇，基础界面搭建


• # 鸿蒙HarmonyOS从零实现类微信app效果第二篇，我的+发现页面实现

鸿蒙的arkui，使用typescript作为基调，然后响应式开发，对于我这个old android来说，确实挺惊艳的。而且在模拟器中运行起来也很快，写demo的过程鸡血满满，着实很愉快。

后面自己写的文章，也在掘金站点上获得了不错的评价。

打击

今天下午，刚好同事有一个遥遥领先（meta 40 pro），鸿蒙4.0版本。

怀着秀操作的想法，在同事手机上运行了起来。very nice。 一切出奇的顺利。

but ...

尼玛，点击的时候，直接卡住不对，黑屏。让人瞬间崩溃。

本着优先怀疑自己的原则，我找了一个官方的demo。 运行起来。

额...

尼玛。还是点击之后卡住了，大概30s之后，才跳转到新的页面。

这一切，让我熬夜掉的头发瞬间崩溃。

放弃了...

放弃了...

后续

和其他学习鸿蒙的伙伴沟通，也遇到了同样的问题，真机不能运行，会卡线程。但是按下home键，再次回到界面，页面会刷新过来。

我个人暂时决定搁置对于鸿蒙开发的学习了，后续如果慢慢变得比较成熟之后，再次接触学习吧。

后续个人计划：

• 1、还是会持续关注后续版本是否真机能运行，传言api 10对黑屏和真机无法运行的修复了。奈何官方所有渠道的编译器都没有api 10 的模拟器，真机4.0按道理是支持api10，但是还是黑屏，再持续观察吧。插个眼。


• 2、为了贯彻执行持续学习。后续可能会持续更新jetpack compose相关内容，包含且不局限于 compose desktop以及multi platform

最新情报：有网友告知我，在meta60上是运行没问题的，可能是最新版4.0是ok的，那么结论就是目前真机适配不完善

"Null 很糟糕." - Doug Lea。

Doug Lea 是一位美国的计算机科学家，他是 Java 平台的并发和集合框架的主要设计者之一。他在 2014 年的一篇文章中说过：“Null sucks.”1，意思是 null 很糟糕。他认为 null 是一种不明确的表示，它既可以表示一个值不存在，也可以表示一个值未知，也可以表示一个值无效。这样就会导致很多逻辑错误和空指针异常，给程序员带来很多麻烦。他建议使用 Optional 类来封装可能为空的值，从而提高代码的可读性和健壮性。

"发明 null 引用是我的十亿美元错误。" - Sir C. A. R. Hoare。

Sir C. A. R. Hoare 是一位英国的计算机科学家，他是快速排序算法、Hoare 逻辑和通信顺序进程等重要概念的发明者。他在 2009 年的一个软件会议上道歉说：“I call it my billion-dollar mistake. It was the invention of the null reference in 1965.”，意思是他把 null 引用称为他的十亿美元错误。他说他在 1965 年设计 ALGOL W 语言时，引入了 null 引用的概念，用来表示一个对象变量没有指向任何对象。他当时认为这是一个很简单和自然的想法，但后来发现这是一个非常糟糕的设计，因为它导致了无数的错误、漏洞和系统崩溃。他说他应该使用一个特殊的对象来表示空值，而不是使用 null。

自作者从事 Java 编程一来，就与 null 引用相伴，与 NullPointerException 相遇已经是家常便饭了。

null 引用是一种表示一个对象变量没有指向任何对象的方式，它是 Java 语言中的一个特殊值，也是导致空指针异常（NullPointerException）的主要原因。虽然 null 引用可以用来表示一个值不存在或未知，也可以用来节省内存空间。但是它也不符合面向对象的思想，因为它不是一个对象，不能调用任何方法或属性。

可以看到，null 引用并不好，我们应该尽量避免使用 null，那么我们该怎么避免 null 引用引起的逻辑错误和运行时异常嘞？

其实这个问题 Java 的设计者也知道，于是他们在 Java8 之后设计引入了 Optional 类解决这个问题，本文将给大家详细介绍下 Optional 类的设计目的以及使用方法。

Optional 类是什么？

Optional 类是 java 8 中引入的一个新的类，它的作用是封装一个可能为空的值，从而避免空指针异常（NullPointerException）。Optional 类可以看作是一个容器，它可以包含一个非空的值，也可以为空。Optional 类提供了一些方法，让我们可以更方便地处理可能为空的值，而不需要显式地进行空值检查或者使用 null。

推荐作者开源的 H5 商城项目waynboot-mall，这是一套全部开源的微商城项目，包含三个项目：运营后台、H5 商城前台和服务端接口。实现了商城所需的首页展示、商品分类、商品详情、商品 sku、分词搜索、购物车、结算下单、支付宝/微信支付、收单评论以及完善的后台管理等一系列功能。 技术上基于最新得 Springboot3.0、jdk17，整合了 MySql、Redis、RabbitMQ、ElasticSearch 等常用中间件。分模块设计、简洁易维护，欢迎大家点个 star、关注我。

github 地址：github.com/wayn111/way…

Optional 类的设计

Optional 类的设计是基于函数式编程的思想，它借鉴了 Scala 和 Haskell 等语言中的 Option 类型。Optional 类实现了 java.util.function 包中的 Supplier、Consumer、Predicate、Function 等接口，这使得它可以和 lambda 表达式或者方法引用一起使用，形成更简洁和优雅的代码。

Optional 类被 final 修饰，因此它是一个不可变的类，它有两个静态方法用于创建 Optional 对象。

Optional.empty()

Optional.empty 表示一个空的 Optional 对象，它不包含任何值。

// 创建一个空的 Optional 对象

Optional empty = Optional.empty();

Optional.of(T value)

Optional.of 表示一个非空的 Optional 对象，它包含一个非空的值。

// 创建一个非空的 Optional 对象

Optional hello = Optional.of("Hello");

Optional.ofNullable(T value)

注意，如果我们使用 Optional.of 方法传入一个 null 值，会抛出 NullPointerException。如果我们不确定一个值是否为空，可以使用 Optional.ofNullable 方法，它会根据值是否为空，返回一个相应的 Optional 对象。例如：

// 创建一个可能为空的 Optional 对象

Optional name = Optional.ofNullable("Hello");

Optional 对象的使用方法

Optional 对象提供了一些方法，让我们可以更方便地处理可能为空的值，而不需要显式地进行空值检查或者使用 null。以下是一些常用的方法。

isPresent()

判断 Optional 对象是否包含一个非空的值，返回一个布尔值。

get()

如果 Optional 对象包含一个非空的值，返回该值，否则抛出 NoSuchElementException 异常。

// 使用 isPresent 和 get 方法

Optional name = Optional.ofNullable("tom");

if (name.isPresent()) {

    System.out.println("Hello, " + name.get());

} else {

    System.out.println("Name is not available");

}

// 输出：Hello tom

ifPresent(Consumer action)

如果 Optional 对象包含一个非空的值，执行给定的消费者操作，否则什么也不做。

// 使用 ifPresent(Consumer action)

Optional name = Optional.ofNullable("tom");

name.ifPresent(s -> {

    System.out.println("Hello, " + name.get());

});

// 输出：Hello tom

orElse(T other)

如果 Optional 对象包含一个非空的值，返回该值，否则返回给定的默认值。

// 使用 orElse(T other)

Optional name = Optional.ofNullable(null);

String greeting = "Hello, " + name.orElse("Guest");

System.out.println(greeting);

// 输出：Hello Guest

orElseGet(Supplier supplier)

如果 Optional 对象包含一个非空的值，返回该值，否则返回由给定的供应者操作生成的值。

// 使用 orElseGet(Supplier supplier)

Optional name = Optional.ofNullable(null);

String greeting = "Hello, " + name.orElseGet(() -> "Guset");

System.out.println(greeting);

// 输出：Hello Guset

orElseThrow(Supplier exceptionSupplier)

如果 Optional 对象包含一个非空的值，返回该值，否则抛出由给定的异常供应者操作生成的异常。

// 使用 orElseThrow(Supplier exceptionSupplier)

Optional name = Optional.ofNullable(null);

String greeting = "Hello, " + name.orElseThrow(() -> new NullPointerException("null"));

// 抛出 java.lang.NullPointerException: null 异常

map(Function mapper)

如果 Optional 对象包含一个非空的值，对该值应用给定的映射函数，返回一个包含映射结果的 Optional 对象，否则返回一个空的 Optional 对象。

// 使用 map(Function mapper)

Optional name = Optional.ofNullable("tom");

String greeting = "Hello, " + name.map(s -> s.toUpperCase()).get();

System.out.println(greeting);

// 输出：Hello TOM

flatMap(Function> mapper)

如果 Optional 对象包含一个非空的值，对该值进行 mapper 参数操作，返回新的 Optional 对象，否则返回一个空的 Optional 对象。

// 使用 flatMap(Function> mapper)

Optional name = Optional.ofNullable("tom");

String greeting = name.flatMap(s -> Optional.of("Hello " + s)).get();

System.out.println(greeting);

// 输出：Hello tom

filter(Predicate predicate)

如果 Optional 对象包含一个非空的值，并且该值满足给定的谓词条件，返回包含该值的 Optional 对象，否则返回一个空的 Optional 对象。

// filter(Predicate predicate)

Optional name = Optional.ofNullable("tom");

String greeting = "Hello " + name.filter(s -> !s.isEmpty()).get();

System.out.println(greeting);

// 输出：Hello tom

Java 9 中 Optional 改进

Java 9 中 Optional 类有了一些改进，主要是增加了三个新的方法，分别是 stream()、ifPresentOrElse() 和 or()。这些方法可以让我们更方便地处理可能为空的值，以及和流或其他返回 Optional 的方法结合使用。我来详细讲解一下这些方法的作用和用法。

stream()

这个方法可以将一个 Optional 对象转换为一个 Stream 对象，如果 Optional 对象包含一个非空的值，那么返回的 Stream 对象就包含这个值，否则返回一个空的 Stream 对象。这样我们就可以利用 Stream 的各种操作来处理 Optional 的值，而不需要显式地判断是否为空。我们可以用 stream() 方法来过滤一个包含 Optional 的列表，只保留非空的值，如下所示：

List> list = Arrays.asList(

        Optional.empty(),

        Optional.of("A"),

        Optional.empty(),

        Optional.of("B")

);



// 使用 stream() 方法过滤列表，只保留非空的值

List filteredList = list.stream()

        .flatMap(Optional::stream)

        .collect(Collectors.toList());



System.out.println(filteredList);

// 输出 [A, B]

ifPresentOrElse(Consumer action, Runnable emptyAction)

这个方法可以让我们在 Optional 对象包含值或者为空时，执行不同的操作。它接受两个参数，一个是 Consumer 类型的 action，一个是 Runnable 类型的 emptyAction。如果 Optional 对象包含一个非空的值，那么就执行 action.accept(value)，如果 Optional 对象为空，那么就执行 emptyAction.run()。这样我们就可以避免使用 if-else 语句来判断 Optional 是否为空，而是使用函数式编程的方式来处理不同的情况。我们可以用 ifPresentOrElse() 方法来打印 Optional 的值，或者提示不可用，如下所示 ：

Optional optional = Optional.of(1);

optional.ifPresentOrElse(

    x -> System.out.println("Value: " + x),

    () -> System.out.println("Not Present.")

);



optional = Optional.empty();

optional.ifPresentOrElse(

    x -> System.out.println("Value: " + x),

    () -> System.out.println("Not Present.")

);



// 输出：Value: 1

// 输出：Not Present.

or(Supplier> supplier)

这个方法可以让我们在 Optional 对象为空时，返回一个预设的值。它接受一个 Supplier 类型的 supplier，如果 Optional 对象包含一个非空的值，那么就返回这个 Optional 对象本身，如果 Optional 对象为空，那么就返回 supplier.get() 返回的 Optional 对象。这样我们就可以避免使用三元运算符或者其他方式来设置默认值，而是使用函数式编程的方式来提供备选值。我们可以用 or() 方法来设置 Optional 的默认值，如下所示：

Optional optional = Optional.of("Hello ");

Supplier> supplier = () -> Optional.of("tom");

optional = optional.or(supplier);

optional.ifPresent(x -> System.out.println(x));



optional = Optional.empty();

optional = optional.or(supplier);

optional.ifPresent(x -> System.out.println(x));



// 输出：Hello 

// 输出：tom

为什么我推荐你使用 Optional 类

最后我总结一下使用 Optional 类的几个好处：

总之，Optional 类是一个非常有用的类，它可以帮助我们更好地处理可能为空的值，提高代码的质量和效率。所以我强烈推荐你在 Java 开发中使用 Optional 类，你会发现它的魅力和好处。

大家好，我是哪吒。

在开发中，我们经常会遇到这样的需求，将Excel的数据导入数据库中。

一、一般我会这样做：

操作起来，如果文件比较多，数据量都很大的时候，会非常慢。

访问之后，感觉没什么反应，实际上已经在读取 + 入库了，只是比较慢而已。

读取一个10万行的Excel，居然用了191s，我还以为它卡死了呢！

private void readXls(String filePath, String filename) throws Exception {

    @SuppressWarnings("resource")

    XSSFWorkbook xssfWorkbook = new XSSFWorkbook(new FileInputStream(filePath));

    // 读取第一个工作表

    XSSFSheet sheet = xssfWorkbook.getSheetAt(0);

    // 总行数

    int maxRow = sheet.getLastRowNum();



    StringBuilder insertBuilder = new StringBuilder();



    insertBuilder.append("insert int0 ").append(filename).append(" ( UUID,");



    XSSFRow row = sheet.getRow(0);

    for (int i = 0; i < row.getPhysicalNumberOfCells(); i++) {

        insertBuilder.append(row.getCell(i)).append(",");

    }



    insertBuilder.deleteCharAt(insertBuilder.length() - 1);

    insertBuilder.append(" ) values ( ");



    StringBuilder stringBuilder = new StringBuilder();

    for (int i = 1; i <= maxRow; i++) {

        XSSFRow xssfRow = sheet.getRow(i);

        String id = "";

        String name = "";

        for (int j = 0; j < row.getPhysicalNumberOfCells(); j++) {

            if (j == 0) {

                id = xssfRow.getCell(j) + "";

            } else if (j == 1) {

                name = xssfRow.getCell(j) + "";

            }

        }



        boolean flag = isExisted(id, name);

        if (!flag) {

            stringBuilder.append(insertBuilder);

            stringBuilder.append('\'').append(uuid()).append('\'').append(",");

            for (int j = 0; j < row.getPhysicalNumberOfCells(); j++) {

                stringBuilder.append('\'').append(value).append('\'').append(",");

            }

            stringBuilder.deleteCharAt(stringBuilder.length() - 1);

            stringBuilder.append(" )").append("\n");

        }

    }



    List collect = Arrays.stream(stringBuilder.toString().split("\n")).collect(Collectors.toList());

    int sum = JdbcUtil.executeDML(collect);

}



private static boolean isExisted(String id, String name) {

    String sql = "select count(1) as num from " + static_TABLE + " where ID = '" + id + "' and NAME = '" + name + "'";

    String num = JdbcUtil.executeSelect(sql, "num");

    return Integer.valueOf(num) > 0;

}



private static String uuid() {

    return UUID.randomUUID().toString().replace("-", "");

}

二、谁写的？拖出去，斩了！

优化1：先查询全部数据，缓存到map中，插入前再进行判断，速度快了很多。

优化2：如果单个Excel文件过大，可以采用 异步 + 多线程 读取若干行，分批入库。

优化3：如果文件数量过多，可以采一个Excel一个异步，形成完美的双异步读取插入。

使用双异步后，从 191s 优化到 2s，你敢信？

下面贴出异步读取Excel文件、并分批读取大Excel文件的关键代码。

1、readExcelCacheAsync控制类

@RequestMapping(value = "/readExcelCacheAsync", method = RequestMethod.POST)

@ResponseBody

public String readExcelCacheAsync() {

    String path = "G:\\测试\\data\\";

    try {

		// 在读取Excel之前，缓存所有数据

        USER_INFO_SET = getUserInfo();



        File file = new File(path);

        String[] xlsxArr = file.list();

        for (int i = 0; i < xlsxArr.length; i++) {

            File fileTemp = new File(path + "\\" + xlsxArr[i]);

            String filename = fileTemp.getName().replace(".xlsx", "");

            readExcelCacheAsyncService.readXls(path + filename + ".xlsx", filename);

        }

    } catch (Exception e) {

        logger.error("|#ReadDBCsv|#异常: ", e);

        return "error";

    }

    return "success";

}

2、分批读取超大Excel文件

@Async("async-executor")

public void readXls(String filePath, String filename) throws Exception {

    @SuppressWarnings("resource")

    XSSFWorkbook xssfWorkbook = new XSSFWorkbook(new FileInputStream(filePath));

    // 读取第一个工作表

    XSSFSheet sheet = xssfWorkbook.getSheetAt(0);

    // 总行数

    int maxRow = sheet.getLastRowNum();

    logger.info(filename + ".xlsx，一共" + maxRow + "行数据！");

    StringBuilder insertBuilder = new StringBuilder();



    insertBuilder.append("insert int0 ").append(filename).append(" ( UUID,");



    XSSFRow row = sheet.getRow(0);

    for (int i = 0; i < row.getPhysicalNumberOfCells(); i++) {

        insertBuilder.append(row.getCell(i)).append(",");

    }



    insertBuilder.deleteCharAt(insertBuilder.length() - 1);

    insertBuilder.append(" ) values ( ");



    int times = maxRow / STEP + 1;

    //logger.info("将" + maxRow + "行数据分" + times + "次插入数据库！");

    for (int time = 0; time < times; time++) {

        int start = STEP * time + 1;

        int end = STEP * time + STEP;



        if (time == times - 1) {

            end = maxRow;

        }



        if(end + 1 - start > 0){

            //logger.info("第" + (time + 1) + "次插入数据库！" + "准备插入" + (end + 1 - start) + "条数据！");

            //readExcelDataAsyncService.readXlsCacheAsync(sheet, row, start, end, insertBuilder);

            readExcelDataAsyncService.readXlsCacheAsyncMybatis(sheet, row, start, end, insertBuilder);

        }

    }

}

3、异步批量入库

@Async("async-executor")

public void readXlsCacheAsync(XSSFSheet sheet, XSSFRow row, int start, int end, StringBuilder insertBuilder) {

    StringBuilder stringBuilder = new StringBuilder();

    for (int i = start; i <= end; i++) {

        XSSFRow xssfRow = sheet.getRow(i);

        String id = "";

        String name = "";

        for (int j = 0; j < row.getPhysicalNumberOfCells(); j++) {

            if (j == 0) {

                id = xssfRow.getCell(j) + "";

            } else if (j == 1) {

                name = xssfRow.getCell(j) + "";

            }

        }



		// 先在读取Excel之前，缓存所有数据，再做判断

        boolean flag = isExisted(id, name);

        if (!flag) {

            stringBuilder.append(insertBuilder);

            stringBuilder.append('\'').append(uuid()).append('\'').append(",");

            for (int j = 0; j < row.getPhysicalNumberOfCells(); j++) {

                stringBuilder.append('\'').append(value).append('\'').append(",");

            }

            stringBuilder.deleteCharAt(stringBuilder.length() - 1);

            stringBuilder.append(" )").append("\n");

        }

    }



    List collect = Arrays.stream(stringBuilder.toString().split("\n")).collect(Collectors.toList());

    if (collect != null && collect.size() > 0) {

        int sum = JdbcUtil.executeDML(collect);

    }

}



private boolean isExisted(String id, String name) {

    return ReadExcelCacheAsyncController.USER_INFO_SET.contains(id + "," + name);

}

4、异步线程池工具类

@Async的作用就是异步处理任务。

在使用@Async时，如果不指定线程池的名称，也就是不自定义线程池，@Async是有默认线程池的，使用的是Spring默认的线程池SimpleAsyncTaskExecutor。

默认线程池的默认配置如下：

从最大线程数可以看出，在并发情况下，会无限制的创建线程，我勒个吗啊。

也可以通过yml重新配置：

spring:

  task:

    execution:

      pool:

        max-size: 10

        core-size: 5

        keep-alive: 3s

        queue-capacity: 1000

        thread-name-prefix: my-executor

也可以自定义线程池，下面通过简单的代码来实现以下@Async自定义线程池。

@EnableAsync// 支持异步操作

@Configuration

public class AsyncTaskConfig {



    /**

     * com.google.guava中的线程池

     * @return

     */

    @Bean("my-executor")

    public Executor firstExecutor() {

        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("my-executor").build();

        // 获取CPU的处理器数量

        int curSystemThreads = Runtime.getRuntime().availableProcessors() * 2;

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(curSystemThreads, 100,

                200, TimeUnit.SECONDS,

                new LinkedBlockingQueue<>(), threadFactory);

        threadPool.allowsCoreThreadTimeOut();

        return threadPool;

    }



    /**

     * Spring线程池

     * @return

     */

    @Bean("async-executor")

    public Executor asyncExecutor() {

        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();

        // 核心线程数

        taskExecutor.setCorePoolSize(24);

        // 线程池维护线程的最大数量，只有在缓冲队列满了之后才会申请超过核心线程数的线程

        taskExecutor.setMaxPoolSize(200);

        // 缓存队列

        taskExecutor.setQueueCapacity(50);

        // 空闲时间，当超过了核心线程数之外的线程在空闲时间到达之后会被销毁

        taskExecutor.setKeepAliveSeconds(200);

        // 异步方法内部线程名称

        taskExecutor.setThreadNamePrefix("");



        /**

         * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略

         * 通常有以下四种策略：

         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

         * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）

         * ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功

         */

        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        taskExecutor.initialize();

        return taskExecutor;

    }

}

5、异步失效的原因

三、线程池中的核心线程数设置问题

有一个问题，一直没时间摸索，线程池中的核心线程数CorePoolSize、最大线程数MaxPoolSize，设置成多少，最合适，效率最高。

借着这个机会，测试一下。

1、我记得有这样一个说法，CPU的处理器数量

将核心线程数CorePoolSize设置成CPU的处理器数量，是不是效率最高的？

// 获取CPU的处理器数量

int curSystemThreads = Runtime.getRuntime().availableProcessors() * 2;

Runtime.getRuntime().availableProcessors()获取的是CPU核心线程数，也就是计算资源。

• CPU密集型，线程池大小设置为N，也就是和cpu的线程数相同，可以尽可能地避免线程间上下文切换，但在实际开发中，一般会设置为N+1，为了防止意外情况出现线程阻塞，如果出现阻塞，多出来的线程会继续执行任务，保证CPU的利用效率。


• IO密集型，线程池大小设置为2N，这个数是根据业务压测出来的，如果不涉及业务就使用推荐。

在实际中，需要对具体的线程池大小进行调整，可以通过压测及机器设备现状，进行调整大小。

如果线程池太大，则会造成CPU不断的切换，对整个系统性能也不会有太大的提升，反而会导致系统缓慢。

我的电脑的CPU的处理器数量是24。

那么一次读取多少行最合适呢？

测试的Excel中含有10万条数据，10万/24 = 4166，那么我设置成4200，是不是效率最佳呢？

测试的过程中发现，好像真的是这样的。

2、我记得大家都习惯性的将核心线程数CorePoolSize和最大线程数MaxPoolSize设置成一样的，都爱设置成200。

是随便写的，还是经验而为之？

测试发现，当你将核心线程数CorePoolSize和最大线程数MaxPoolSize都设置为200的时候，第一次它会同时开启150个线程，来进行工作。

这个是为什么？

3、经过数十次的测试

四、通过EasyExcel读取并插入数据库

EasyExcel的方式，我就不写双异步优化了，大家切记陷入低水平勤奋的怪圈。

1、ReadEasyExcelController

@RequestMapping(value = "/readEasyExcel", method = RequestMethod.POST)

@ResponseBody

public String readEasyExcel() {

    try {

        String path = "G:\\测试\\data\\";

        String[] xlsxArr = new File(path).list();

        for (int i = 0; i < xlsxArr.length; i++) {

            String filePath = path + xlsxArr[i];

            File fileTemp = new File(path + xlsxArr[i]);

            String fileName = fileTemp.getName().replace(".xlsx", "");

            List list = new ArrayList<>();

            EasyExcel.read(filePath, UserInfo.class, new ReadEasyExeclAsyncListener(readEasyExeclService, fileName, batchCount, list)).sheet().doRead();

        }

    }catch (Exception e){

        logger.error("readEasyExcel 异常：",e);

        return "error";

    }

    return "suceess";

}

2、ReadEasyExeclAsyncListener

public ReadEasyExeclService readEasyExeclService;

	// 表名

    public String TABLE_NAME;

    // 批量插入阈值

    private int BATCH_COUNT;

    // 数据集合

    private List LIST;



    public ReadEasyExeclAsyncListener(ReadEasyExeclService readEasyExeclService, String tableName, int batchCount, List list) {

        this.readEasyExeclService = readEasyExeclService;

        this.TABLE_NAME = tableName;

        this.BATCH_COUNT = batchCount;

        this.LIST = list;

    }



    @Override

    public void invoke(UserInfo data, AnalysisContext analysisContext) {

        data.setUuid(uuid());

        data.setTableName(TABLE_NAME);

        LIST.add(data);

        if(LIST.size() >= BATCH_COUNT){

            // 批量入库

            readEasyExeclService.saveDataBatch(LIST);

        }

    }



    @Override

    public void doAfterAllAnalysed(AnalysisContext analysisContext) {

        if(LIST.size() > 0){

        	// 最后一批入库

            readEasyExeclService.saveDataBatch(LIST);

        }

    }



    public static String uuid() {

        return UUID.randomUUID().toString().replace("-", "");

    }

}

3、ReadEasyExeclServiceImpl

@Service

public class ReadEasyExeclServiceImpl implements ReadEasyExeclService {



    @Resource

    private ReadEasyExeclMapper readEasyExeclMapper;



    @Override

    public void saveDataBatch(List list) {

    	// 通过mybatis入库

        readEasyExeclMapper.saveDataBatch(list);

        // 通过JDBC入库

        // insertByJdbc(list);

        list.clear();

    }

    

    private void insertByJdbc(List list){

        List sqlList = new ArrayList<>();

        for (UserInfo u : list){

            StringBuilder sqlBuilder = new StringBuilder();

            sqlBuilder.append("insert int0 ").append(u.getTableName()).append(" ( UUID,ID,NAME,AGE,ADDRESS,PHONE,OP_TIME ) values ( ");

            sqlBuilder.append("'").append(ReadEasyExeclAsyncListener.uuid()).append("',")

                            .append("'").append(u.getId()).append("',")

                            .append("'").append(u.getName()).append("',")

                            .append("'").append(u.getAge()).append("',")

                            .append("'").append(u.getAddress()).append("',")

                            .append("'").append(u.getPhone()).append("',")

                            .append("sysdate )");

            sqlList.add(sqlBuilder.toString());

        }



        JdbcUtil.executeDML(sqlList);

    }

}

4、UserInfo

@Data

public class UserInfo {



    private String tableName;



    private String uuid;



    @ExcelProperty(value = "ID")

    private String id;



    @ExcelProperty(value = "NAME")

    private String name;



    @ExcelProperty(value = "AGE")

    private String age;



    @ExcelProperty(value = "ADDRESS")

    private String address;



    @ExcelProperty(value = "PHONE")

    private String phone;

}

引言

在开发Spring Boot应用时，我们经常面临着不同的控制器方法需要处理各种不同类型的响应结果，以及在代码中分散处理异常可能导致项目难以维护的问题。你是否曾经遇到过在不同地方编写相似的返回格式，或者在处理异常时感到有些混乱？这些看似小问题的积累，实际上可能对项目产生深远的影响。统一结果返回和统一异常处理并非只是为了规范代码，更是为了提高团队的协作效率、降低项目维护的难度，并使代码更易于理解和扩展。

本文的目的是帮助你更好地理解和应用Spring Boot中的统一结果返回和统一异常处理。通过详细的讨论和实例演示，我们将为你提供一套清晰的指南，让你能够在自己的项目中轻松应用这些技术，提高代码质量，减轻开发压力。

统一结果返回

统一结果返回是一种通过定义通用的返回格式，使所有的响应结果都符合同一标准的方法。这有助于提高代码的一致性，减少重复代码的编写，以及使客户端更容易理解和处理API的响应。统一结果返回不仅规范了代码结构，还能提高团队协作效率，降低项目维护的难度。

接下来让我们一起看看在SpringBoot中如何实现统一结果返回。

1. 定义通用的响应对象

当实现统一结果返回时，需要创建一个通用的响应对象，定义成功和失败的返回情况，并确保在接口中使用这个通用返回对象。

@Setter  

@Getter  

public class ResultResponse<T> implements Serializable {  

    private static final long serialVersionUID = -1133637474601003587L;  



    /**  

     * 接口响应状态码  

     */  

    private Integer code;  



    /**  

     * 接口响应信息  

     */  

    private String msg;  



    /**  

     * 接口响应的数据  

     */  

    private T data;

}    

2. 定义接口响应状态码

统一结果返回的关键之一是规定一套通用的状态码。这有助于客户端更容易地理解和处理 API 的响应，同时也为开发者提供了一致的标准。通常，一些 HTTP 状态码已经被广泛接受，如：

• 200 OK：表示成功处理请求。


• 201 Created：表示成功创建资源。


• 204 No Content：表示成功处理请求，但没有返回任何内容。

对于错误情况，也可以使用常见的 HTTP 状态码，如：

• 400 Bad Request：客户端请求错误。


• 401 Unauthorized：未授权访问。


• 404 Not Found：请求资源不存在。


• 500 Internal Server Error：服务器内部错误。

除了 HTTP 状态码外，你还可以定义自己的应用程序特定状态码，以表示更具体的情况。确保文档中清晰地说明了每个状态码所代表的含义，使开发者能够正确地解释和处理它们。

public enum StatusEnum {  

    SUCCESS(200 ,"请求处理成功"),  

    UNAUTHORIZED(401 ,"用户认证失败"),  

    FORBIDDEN(403 ,"权限不足"),  

    SERVICE_ERROR(500, "服务器去旅行了，请稍后重试"),  

    PARAM_INVALID(1000, "无效的参数"),  

    ;  

    public final Integer code;  



    public final String message;  



    StatusEnum(Integer code, String message) {  

        this.code = code;  

        this.message = message;  

    }  



}

3. 定义统一的成功和失败的处理方法

定义统一的成功和失败的响应方法有助于保持代码一致性和规范性，简化控制器逻辑，提高代码复用性，降低维护成本，提高可读性，促进团队协作，以及更便于进行测试。

/**  

 * 封装成功响应的方法  

 * @param data 响应数据  

 * @return reponse  

 * @param <T> 响应数据类型  

 */  

public static <T> ResultResponse<T> success(T data) {  



    ResultResponse<T> response = new ResultResponse<>();  

    response.setData(data);  

    response.setCode(StatusEnum.SUCCESS.code);  

    return response;  

}  



/**  

 * 封装error的响应  

 * @param statusEnum error响应的状态值  

 * @return  

 * @param <T>  

 */  

public static <T> ResultResponse<T> error(StatusEnum statusEnum) {  

   return error(statusEnum, statusEnum.message);  

}  



/**  

 * 封装error的响应  可自定义错误信息

 * @param statusEnum error响应的状态值  

 * @return  

 * @param <T>  

 */  

public static <T> ResultResponse<T> error(StatusEnum statusEnum, String errorMsg) {  

    ResultResponse<T> response = new ResultResponse<>();  

    response.setCode(statusEnum.code);  

    response.setMsg(errorMsg);  

    return response;  

}

4. web层统一响应结果

在web层使用统一结果返回的目的是将业务逻辑的处理结果按照预定的通用格式进行封装，以提高代码的一致性和可读性。

@RestController  

@RequestMapping("user")  

@Validated  

@Slf4j  

public class UserController {  



    private IUserService userService;  



    /**  

     * 创建用户  

     * @param requestVO  

     * @return  

     */  

    @PostMapping("create")  

    public ResultResponse<Void> createUser(@Validated @RequestBody UserCreateRequestVO requestVO){  

        return ResultResponse.success(null);  

    }



    /**  

     * 根据用户ID获取用户信息  

     * @param userId 用户id  

     * @return 用户信息  

     */  

    @GetMapping("info")  

    public ResultResponse<UserInfoResponseVO> getUser(@NotBlank(message = "请选择用户") String userId){  

        final UserInfoResponseVO responseVO = userService.getUserInfoById(userId);  

        return ResultResponse.success(responseVO);  

    }  



    @Autowired  

    public void setUserService(IUserService userService) {  

        this.userService = userService;  

    }  

}

调用接口，响应的信息统一为：

{

    "code": 200,

    "msg": null,

    "data": null

}

{

    "code": 200,

    "msg": null,

    "data": {

        "userId": "121",

        "userName": "码农Academy"

    }

}

统一结果返回通过定义通用的返回格式、成功和失败的返回情况，以及在控制器中使用这一模式，旨在提高代码的一致性、可读性和可维护性。采用统一的响应格式简化了业务逻辑处理流程，使得开发者更容易处理成功和失败的情况，同时客户端也更容易理解和处理 API 的响应。这一实践有助于降低维护成本、提高团队协作效率，并促进代码的规范化。

统一异常处理

统一异常处理的必要性体现在保持代码的一致性、提供更清晰的错误信息、以及更容易排查问题。通过定义统一的异常处理方式，确保在整个应用中对异常的处理保持一致，减少了重复编写相似异常处理逻辑的工作，同时提供友好的错误信息帮助开发者和维护人员更快地定位和解决问题，最终提高了应用的可维护性和可读性。

1.定义统一的异常类

我们需要定义服务中可能抛出的自定义异常类。这些异常类可以继承自RuntimeException，并携带有关异常的相关信息。即可理解为局部异常，用于特定的业务处理中异常。手动埋点抛出。

@Getter  

public class ServiceException extends RuntimeException{  



    private static final long serialVersionUID = -3303518302920463234L;  



    private final StatusEnum status;  



    public ServiceException(StatusEnum status, String message) {  

        super(message);  

        this.status = status;  

    }  



    public ServiceException(StatusEnum status) {  

        this(status, status.message);  

    }  

}

2.异常处理器

创建一个全局的异常处理器，使用@ControllerAdvice 或者 @RestControllerAdvice注解和@ExceptionHandler注解来捕获不同类型的异常，并定义处理逻辑。

2.1 @ControllerAdvice注解

用于声明一个全局控制器建言（Advice），相当于把@ExceptionHandler、@InitBinder和@ModelAttribute注解的方法集中到一个地方。常放在一个特定的类上，这个类被认为是全局异常处理器，可以跨足多个控制器。

当时用@ControllerAdvice时，我们需要在异常处理方法上加上@ResponseBody，同理我们的web接口。但是如果我们使用@RestControllerAdvice 就可以不用加，同理也是web定义的接口

2.2 @ExceptionHandler注解

用于定义异常处理方法，处理特定类型的异常。放在全局异常处理器类中的具体方法上。

通过这两个注解的配合，可以实现全局的异常处理。当控制器中抛出异常时，Spring Boot会自动调用匹配的@ExceptionHandler方法来处理异常，并返回定义的响应。

@Slf4j  

@ControllerAdvice  

public class ExceptionAdvice {  



    /**  

     * 处理ServiceException  

     * @param serviceException ServiceException  

     * @param request 请求参数  

     * @return 接口响应  

     */  

    @ExceptionHandler(ServiceException.class)  

    @ResponseBody  

    public ResultResponse<Void> handleServiceException(ServiceException serviceException, HttpServletRequest request) {  

        log.warn("request {} throw ServiceException \n", request, serviceException);  

        return ResultResponse.error(serviceException.getStatus(), serviceException.getMessage());  

    }  



    /**  

     * 其他异常拦截  

     * @param ex 异常  

     * @param request 请求参数  

     * @return 接口响应  

     */  

    @ExceptionHandler(Exception.class)  

    @ResponseBody  

    public ResultResponse<Void> handleException(Exception ex, HttpServletRequest request) {  

        log.error("request {} throw unExpectException \n", request, ex);  

        return ResultResponse.error(StatusEnum.SERVICE_ERROR);  

    }

}    

3.异常统一处理使用

在业务开发过程中，我们可以在service层处理业务时，可以手动抛出业务异常。由全局异常处理器进行统一处理。

@Service  

@Slf4j  

public class UserServiceImpl implements IUserService {  



    private IUserManager userManager;



    /**  

     * 创建用户  

     *  

     * @param requestVO 请求参数  

     */  

    @Override  

    public void createUser(UserCreateRequestVO requestVO) {  

        final UserDO userDO = userManager.selectUserByName(requestVO.getUserName());  

        if (userDO != null){  

            throw new ServiceException(StatusEnum.PARAM_INVALID, "用户名已存在");  

        }  

    }



    @Autowired  

    public void setUserManager(IUserManager userManager) {  

        this.userManager = userManager;  

    }  

}

@RestController  

@RequestMapping("user")  

@Validated  

@Slf4j  

public class UserController {  



    private IUserService userService;  



    /**  

     * 创建用户  

     * @param requestVO  

     * @return  

     */  

    @PostMapping("create")  

    public ResultResponse<Void> createUser(@Validated @RequestBody UserCreateRequestVO requestVO){  

        userService.createUser(requestVO);  

        return ResultResponse.success(null);  

    }



    @Autowired  

    public void setUserService(IUserService userService) {  

        this.userService = userService;  

    }  

}

当我们请求接口时，假如用户名称已存在，接口就会响应：

{

    "code": 1000,

    "msg": "用户名已存在",

    "data": null

}

统一异常处理带来的好处包括提供一致的异常响应格式，简化异常处理逻辑，记录更好的错误日志，以及更容易排查和解决问题。通过统一处理异常，我们确保在整个应用中对异常的处理方式一致，减少了重复性代码的编写，提高了代码的规范性。简化的异常处理逻辑降低了开发者的工作负担，而更好的错误日志有助于更迅速地定位和解决问题，最终提高了应用的可维护性和稳定性。

其他类型的异常处理

在项目开发过程中，我们还有一些常见的特定异常类型，比如MethodArgumentNotValidException和UnexpectedTypeException等，并为它们定义相应的异常处理逻辑。这些特定异常可能由于请求参数校验失败或意外的数据类型问题而引起，因此有必要为它们单独处理，以提供更具体和友好的异常响应。

1.MethodArgumentNotValidException

由于请求参数校验失败引起的异常，通常涉及到使用@Valid注解或者@Validated进行请求参数校验。我们可以在异常处理器中编写@ExceptionHandler方法，捕获并处理MethodArgumentNotValidException，提取校验错误信息，并返回详细的错误响应。

/**  

 * 参数非法校验  

 * @param ex  

 * @return  

 */  

@ExceptionHandler(MethodArgumentNotValidException.class)  

@ResponseBody  

public ResultResponse<Void> handleMethodArgumentNotValidException(MethodArgumentNotValidException ex) {  

    try {  

        List<ObjectError> errors = ex.getBindingResult().getAllErrors();  

        String message = errors.stream().map(ObjectError::getDefaultMessage).collect(Collectors.joining(","));  

        log.error("param illegal: {}", message);  

        return ResultResponse.error(StatusEnum.PARAM_INVALID, message);  

    } catch (Exception e) {  

        return ResultResponse.error(StatusEnum.SERVICE_ERROR);  

    }  

}

当我们使用@Valid注解或者@Validated进行请求参数校验不通过时，响应结果为：

{

    "code": 1000,

    "msg": "请输入地址信息,用户年龄必须小于60岁,请输入你的兴趣爱好",

    "data": null

}

关于@Valid注解或者@Validated进行参数校验的功能请参考：SpringBoot优雅校验参数

2.UnexpectedTypeException

意外的数据类型异常，通常表示程序运行时发生了不符合预期的数据类型问题。一个常见的使用场景是在数据转换或类型处理的过程中。例如，在使用 Spring 表单绑定或数据绑定时，如果尝试将一个不符合预期类型的值转换为目标类型，就可能抛出 UnexpectedTypeException。这通常会发生在将字符串转换为数字、日期等类型时，如果字符串的格式不符合目标类型的要求。

我们可以在异常处理器中编写@ExceptionHandler方法，捕获并处理UnexpectedTypeException，提供适当的处理方式，例如记录错误日志，并返回合适的错误响应。

@ExceptionHandler(UnexpectedTypeException.class)  

@ResponseBody  

public ResultResponse<Void> handleUnexpectedTypeException(UnexpectedTypeException ex,  

                                                        HttpServletRequest request) {  

    log.error("catch UnexpectedTypeException, errorMessage: \n", ex);  

    return ResultResponse.error(StatusEnum.PARAM_INVALID, ex.getMessage());  

}

当发生异常时，接口会响应：

{

    "code": 500,

    "msg": "服务器去旅行了，请稍后重试",

    "data": null

}

3.ConstraintViolationException

javax.validation.ConstraintViolationException 是 Java Bean Validation（JSR 380）中的一种异常。它通常在使用 Bean Validation 进行数据校验时，如果校验失败就会抛出这个异常。即我们在使用自定义校验注解时，如果不满足校验规则，就会抛出这个错误。

@ExceptionHandler(ConstraintViolationException.class)  

@ResponseBody  

public ResultResponse<Void> handlerConstraintViolationException(ConstraintViolationException ex, HttpServletRequest request) {  

    log.error("request {} throw ConstraintViolationException \n", request, ex);  

    return ResultResponse.error(StatusEnum.PARAM_INVALID, ex.getMessage());  

}

案例请参考：SpringBoot优雅校验参数，注册ConstraintValidator示例中的@UniqueUser校验。

4.HttpMessageNotReadableException

表示无法读取HTTP消息的异常，通常由于请求体不合法或不可解析。

@ResponseBody  

@ResponseStatus(HttpStatus.BAD_REQUEST)  

@ExceptionHandler(HttpMessageNotReadableException.class)  

public ResultResponse<Void> handleHttpMessageNotReadableException(HttpMessageNotReadableException ex,  

HttpServletRequest request) {  

    log.error("request {} throw ucManagerException \n", request, ex);  

    return ResultResponse.error(StatusEnum.SERVICE_ERROR);  

}

5.HttpRequestMethodNotSupportedException

Spring Framework 中的异常类，表示请求的 HTTP 方法不受支持。当客户端发送了一个使用不被服务器支持的 HTTP 方法（如 GET、POST、PUT、DELETE等）的请求时，可能会抛出这个异常。

@ExceptionHandler({HttpRequestMethodNotSupportedException.class, HttpMediaTypeException.class})  

@ResponseBody  

public ResultResponse<Void> handleMethodNotSupportedException(Exception ex) {  

    log.error("HttpRequestMethodNotSupportedException \n", ex);  

    return ResultResponse.error(StatusEnum.HTTP_METHOD_NOT_SUPPORT);  

}

全局异常处理与局部异常处理在Spring Boot应用开发中扮演不同角色。全局异常处理通过统一的异常处理器确保了整个应用对异常的处理一致性，减少了冗余代码，提高了代码的整洁度。然而，这种方式可能在灵活性上略显不足，无法满足每个具体控制器或业务场景的个性化需求。

相比之下，局部异常处理能够为每个控制器或业务场景提供更具体、灵活的异常处理逻辑，允许定制化的异常响应。这使得在复杂的项目中更容易处理特定的异常情况，同时提供更详细的错误信息。然而，局部异常处理可能带来代码冗余和维护难度的问题，特别是在大型项目中。

在实际应用中，选择全局异常处理还是局部异常处理应根据项目规模和需求进行权衡。对于小型项目或简单场景，全局异常处理可能是一种更简单、合适的选择。而对于大型项目或需要个性化异常处理的复杂业务逻辑，局部异常处理则提供了更为灵活的方案。最佳实践是在项目中根据具体情况灵活使用这两种方式，以平衡一致性和个性化需求。

最佳实践与注意事项

1. 最佳实践

• 统一响应格式：  在异常处理中，使用统一的响应格式有助于客户端更容易理解和处理错误。通常，返回一个包含错误码、错误信息和可能的详细信息的响应对象。


• 详细错误日志：  在异常处理中记录详细的错误日志，包括异常类型、发生时间、请求信息等。这有助于快速定位和解决问题。


• 使用HTTP状态码：  根据异常的性质，选择适当的HTTP状态码。例如，使用HttpStatus.NOT_FOUND表示资源未找到，HttpStatus.BAD_REQUEST表示客户端请求错误等。


• 异常分类：  根据异常的种类，合理分类处理。可以定义不同的异常类来表示不同的异常情况，然后在异常处理中使用@ExceptionHandler分别处理。


• 全局异常处理：  使用全局异常处理机制来捕获未被特定控制器处理的异常，以确保应用在整体上的健壮性。

2 注意事项

• 不滥用异常：  异常应该用于表示真正的异常情况，而不是用作控制流程。滥用异常可能导致性能问题和代码可读性降低。


• 不忽略异常：  避免在异常处理中忽略异常或仅仅打印日志而不进行适当的处理。这可能导致潜在的问题被掩盖，难以追踪和修复。


• 避免空的catch块：  不要在catch块中什么都不做，这样会使得异常难以被发现。至少在catch块中记录日志，以便了解异常的发生。


• 适时抛出异常：  不要过于吝啬地抛出异常，但也不要无谓地滥用。在必要的时候使用异常，例如表示无法继续执行的错误情况。


• 测试异常场景：  编写单元测试时，确保覆盖异常场景，验证异常的正确抛出和处理。

总结

异常处理在应用开发中是至关重要的一环，它能够提高应用的健壮性、可读性和可维护性。全局异常处理和局部异常处理各有优劣，需要根据项目的规模和需求来灵活选择。通过采用统一的响应格式、详细的错误日志、适当的HTTP状态码等最佳实践，可以使异常处理更为有效和易于管理。同时，注意避免滥用异常、忽略异常、适时抛出异常等注意事项，有助于确保异常处理的质量。在开发过程中，持续关注和优化异常处理，将有助于提高应用的稳定性和用户体验。

本文已收录我的个人博客：码农Academy的博客，专注分享Java技术干货，包括Java基础、Spring Boot、Spring Cloud、Mysql、Redis、Elasticsearch、中间件、架构设计、面试题、程序员攻略等

引言

字符串操作是 Java 中使用最频繁的操作，没有之一。其中非常常见的操作之一就是对字符串的组织，由于常见所以就衍生了多种方案。比如我们要实现 x + y = ?，方案有如下几种

• 使用 + 进行字符串拼接

String s = x + " + " + y + " = " + (x + y);

• 使用 StringBuilder

String s = new StringBuilder()

                 .append(x)

                 .append(" + ")

                 .append(y)

                 .append(" = ")

                 .append(x + y)

                 .toString()

• String::format 和 String::formatted 将格式字符串从参数中分离出来

String s = String.format("%2$d + %1$d = %3$d", x, y, x + y);

or 

String s = "%2$d + %1$d = %3$d".formatted(x, y, x + y);

• java.text.MessageFormat

String s = MessageFormat.format("{0} + {1} = {2}", x,y, x + y);

这四种方案虽然都可以解决，但很遗憾的是他们或多或少都有点儿缺陷，尤其是面对 Java 13 引入的文本块（Java 13 新特性—文本块）更是束手无措。

字符串模板

为了简化字符串的构造和格式化，Java 21 引入字符串模板功能，该特性主要目的是为了提高在处理包含多个变量和复杂格式化要求的字符串时的可读性和编写效率。

它的设计目标是：

• 通过简单的方式表达混合变量的字符串，简化 Java 程序的编写。


• 提高混合文本和表达式的可读性，无论文本是在单行源代码中（如字符串字面量）还是跨越多行源代码（如文本块）。


• 通过支持对模板及其嵌入式表达式的值进行验证和转换，提高根据用户提供的值组成字符串并将其传递给其他系统（如构建数据库查询）的 Java 程序的安全性。


• 允许 Java 库定义字符串模板中使用的格式化语法（java.util.Formatter ），从而保持灵活性。


• 简化接受以非 Java 语言编写的字符串（如 SQL、XML 和 JSON）的 API 的使用。


• 支持创建由字面文本和嵌入式表达式计算得出的非字符串值，而无需通过中间字符串表示。

该特性处理字符串的新方法称为：Template Expressions，即：模版表达式。它是 Java 中的一种新型表达式，不仅可以执行字符串插值，还可以编程，从而帮助开发人员安全高效地组成字符串。此外，模板表达式并不局限于组成字符串——它们可以根据特定领域的规则将结构化文本转化为任何类型的对象。

STR 模板处理器

STR 是 Java 平台定义的一种模板处理器。它通过用表达式的值替换模板中的每个嵌入表达式来执行字符串插值。使用 STR 的模板表达式的求值结果是一个字符串。

STR 是一个公共静态 final 字段，会自动导入到每个 Java 源文件中。

我们先看一个简单的例子：

    @Test

    public void STRTest() {

        String sk = "死磕 Java 新特性";

        String str1 = STR."{sk}，就是牛";

        System.out.println(str1);

    }

// 结果.....

死磕 Java 新特性，就是牛

上面的 STR."{sk}，就是牛" 就是一个模板表达式，它主要包含了三个部分：

• 模版处理器：STR


• 包含内嵌表达式（{blog}）的模版


• 通过.把前面两部分组合起来，形式如同方法调用

当模版表达式运行的时候，模版处理器会将模版内容与内嵌表达式的值组合起来，生成结果。

这个例子只是 STR模版处理器一个很简单的功能，它可以做的事情有很多。

• 数学运算

比如上面的 x + y = ?：

    @Test

    public void STRTest() {

        int x = 1,y =2;

        String str = STR."{x} + {y} = {x + y}";

        System.out.println(str);

    }

这种写法是不是简单明了了很多？

• 调用方法

STR模版处理器还可以调用方法，比如：

String str = STR."今天是：{ LocalDate.now()} ";

当然也可以调用我们自定义的方法：

    @Test

    public void STRTest() {

        String str = STR."{getSkStr()},就是牛";

        System.out.println(str);

    }



    public String getSkStr() {

        return "死磕 Java 新特性";

    }

• 访问成员变量

STR模版处理器还可以访问成员变量，比如：

public record User(String name,Integer age) {

}



@Test

public void STRTest() {

  User user = new User("大明哥",18);

  String str = STR."{user.name()}今年{user.age()}";

  System.out.println(str);

}

需要注意的是，字符串模板表达式中的嵌入表达式数量没有限制，它从左到右依次求值，就像方法调用表达式中的参数一样。例如：

    @Test

    public void STRTest() {

        int i = 0;

        String str = STR."{i++},{i++},{i++},{i++},{i++}";

        System.out.println(str);

    }

// 结果......

0,1,2,3,4

同时，表达式中也可以嵌入表达式：

    @Test

    public void STRTest() {

        String name = "大明哥";

        String sk = "死磕 Java 新特性";

        String str = STR."{name}的{STR."{sk},就是牛..."}";

        System.out.println(str);

    }

// 结果......

大明哥的死磕 Java 新特性,就是牛...

但是这种嵌套的方式会比较复杂，容易搞混，一般不推荐。

多行模板表达式

为了解决多行字符串处理的复杂性，Java 13 引入文本块（Java 13 新特性—文本块），它是使用三个双引号（"""）来标记字符串的开始和结束，允许字符串跨越多行而无需显式的换行符或字符串连接。如下：

String html = """

              <html>

                  <body>

                      <h2>skjava.com</h2>

                      <ul>

                        <li>死磕 Java 新特性</li>

                        <li>死磕 Java 并发</li>

                        <li>死磕 Netty</li>

                        <li>死磕 Redis</li>

                      </ul>

                  </body>

              </html>

              """;

如果字符串模板表达式，我们就只能拼接这串字符串了，这显得有点儿繁琐和麻烦。而字符串模版表达式也支持多行字符串处理，我们可以利用它来方便的组织html、json、xml等字符串内容，比如这样：

    @Test

    public void STRTest() {

        String title = "skjava.com";

        String sk1 = "死磕 Java 新特性";

        String sk2 = "死磕 Java 并发";

        String sk3 = "死磕 Netty";

        String sk4 = "死磕 Redis";



        String html = STR."""

              <html>

                  <body>

                      <h2>{title}</h2>

                      <ul>

                        <li>{sk1}</li>

                        <li>{sk2}</li>

                        <li>{sk3}</li>

                        <li>{sk4}</li>

                      </ul>

                  </body>

              </html>

              """;

        System.out.println(html);

    }

如果决定定义四个 sk 变量麻烦，可以整理为一个集合，然后调用方法生成 <li> 标签。

FMT 模板处理器

FMT 是 Java 定义的另一种模板处理器。它除了与STR模版处理器一样提供插值能力之外，还提供了左侧的格式化处理。下面我们来看看他的功能。比如我们要整理模式匹配的 Switch 表达在 Java 版本中的迭代，也就是下面这个表格

如果使用 STR 模板处理器，代码如下：

    @Test

    public void STRTest() {

        SwitchHistory[] switchHistories = new SwitchHistory[]{

                new SwitchHistory("Java 17","第一次预览","JEP 406","引入模式匹配的 Swith 表达式作为预览特性。"),

                new SwitchHistory("Java 18","第二次预览","JEP 420","对其做了改进和细微调整"),

                new SwitchHistory("Java 19","第三次预览","JEP 427","进一步优化模式匹配的 Swith 表达式"),

                new SwitchHistory("Java 20","第四次预览","JEP 433",""),

                new SwitchHistory("Java 21","正式特性","JEP 441","成为正式特性"),

        };



        String history = STR."""

                Java 版本     更新类型    JEP 更新内容

                {switchHistories[0].javaVersion()} {switchHistories[0].updateType()} {switchHistories[0].jep()} {switchHistories[0].content()}

                {switchHistories[1].javaVersion()} {switchHistories[1].updateType()} {switchHistories[1].jep()} {switchHistories[1].content()}

                {switchHistories[2].javaVersion()} {switchHistories[2].updateType()} {switchHistories[2].jep()} {switchHistories[2].content()}

                {switchHistories[3].javaVersion()} {switchHistories[3].updateType()} {switchHistories[3].jep()} {switchHistories[3].content()}

                {switchHistories[4].javaVersion()} {switchHistories[4].updateType()} {switchHistories[4].jep()} {switchHistories[4].content()}

                """;

        System.out.println(history);

    }

得到的效果是这样的：

Java 版本     更新类型    JEP 更新内容

Java 17 第一次预览 JEP 406 引入模式匹配的 Swith 表达式作为预览特性。

Java 18 第二次预览 JEP 420 对其做了改进和细微调整

Java 19 第三次预览 JEP 427 进一步优化模式匹配的 Swith 表达式

Java 20 第四次预览 JEP 433 

Java 21 正式特性 JEP 441 成为正式特性

是不是很丑？完全对不齐，没法看。为了解决这个问题，就可以采用FMT模版处理器，在每一列左侧定义格式：

   @Test

    public void STRTest() {

        SwitchHistory[] switchHistories = new SwitchHistory[]{

                new SwitchHistory("Java 17","第一次预览","JEP 406","引入模式匹配的 Swith 表达式作为预览特性。"),

                new SwitchHistory("Java 18","第二次预览","JEP 420","对其做了改进和细微调整"),

                new SwitchHistory("Java 19","第三次预览","JEP 427","进一步优化模式匹配的 Swith 表达式"),

                new SwitchHistory("Java 20","第四次预览","JEP 433",""),

                new SwitchHistory("Java 21","正式特性","JEP 441","成为正式特性"),

        };



        String history = FMT."""

                Java 版本     更新类型        JEP             更新内容

                %-10s{switchHistories[0].javaVersion()}  %-9s{switchHistories[0].updateType()} %-10s{switchHistories[0].jep()} %-20s{switchHistories[0].content()}

                %-10s{switchHistories[1].javaVersion()}  %-9s{switchHistories[1].updateType()} %-10s{switchHistories[1].jep()} %-20s{switchHistories[1].content()}

                %-10s{switchHistories[2].javaVersion()}  %-9s{switchHistories[2].updateType()} %-10s{switchHistories[2].jep()} %-20s{switchHistories[2].content()}

                %-10s{switchHistories[3].javaVersion()}  %-9s{switchHistories[3].updateType()} %-10s{switchHistories[3].jep()} %-20s{switchHistories[3].content()}

                %-10s{switchHistories[4].javaVersion()}  %-9s{switchHistories[4].updateType()} %-10s{switchHistories[4].jep()} %-20s{switchHistories[4].content()}

                """;

        System.out.println(history);

    }

输出如下：

Java 版本     更新类型        JEP             更新内容

Java 17     第一次预览     JEP 406    引入模式匹配的 Swith 表达式作为预览特性。

Java 18     第二次预览     JEP 420    对其做了改进和细微调整         

Java 19     第三次预览     JEP 427    进一步优化模式匹配的 Swith 表达式

Java 20     第四次预览     JEP 433                        

Java 21     正式特性       JEP 441    成为正式特性  

1. Get 请求

1.1 以方法的形参接收参数

1.这种方式一般适用参数比较少的情况

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {



    @GetMapping("/detail")

    public Result<User> getUserDetail(String name,String phone) {

        log.info("name:{}",name);

        log.info("phone:{}",phone);

       return  Result.success(null);

    }

}

2.参数用 @RequestParam 标注，表示这个参数需要必传，否则会报错。

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {



    @GetMapping("/detail")

    public Result<User> getUserDetail(@RequestParam String name,@RequestParam String phone) {

        log.info("name:{}",name);

        log.info("phone:{}",phone);

       return  Result.success(null);

    }

}

1.2 以实体类接收参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {



    @GetMapping("/detail")

    public Result<User> getUserDetail(User user) {

        log.info("name:{}",user.getName());

        log.info("phone:{}",user.getPhone());

       return  Result.success(null);

    }

}

注：Get 请求以实体类接收参数时，不能用 RequestParam 注解进行标注，因为不支持这样的方式获取参数。

1.3 通过 HttpServletRequest 接收参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @GetMapping("/detail")

    public Result<User> getUserDetail(HttpServletRequest request) {

        String name = request.getParameter("name");

        String phone = request.getParameter("phone");

        log.info("name:{}",name);

        log.info("phone:{}",phone);

       return  Result.success(null);

    }

}

1.4 通过 @PathVariable 注解接收参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {



    @GetMapping("/detail/{name}/{phone}")

    public Result<User> getUserDetail(@PathVariable String name,@PathVariable String phone) {

        log.info("name:{}",name);

        log.info("phone:{}",phone);

       return  Result.success(null);

    }

}

1.5 接收数组参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {



    @GetMapping("/detail")

    public Result<User> getUserDetail(String[] names) {

        Arrays.asList(names).forEach(name->{

            System.out.println(name);

        });

       return  Result.success(null);

    }

}

1.6 接收集合参数

springboot 接收集合参数，需要用 RequestParam 注解绑定参数，否则会报错！！

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {



    @GetMapping("/detail")

    public Result<User> getUserDetail(@RequestParam List<String> names) {

        names.forEach(name->{

            System.out.println(name);

        });

       return  Result.success(null);

    }

}

2. Post 请求

2.1 以方法的形参接收参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {



    @PostMapping("/save")

    public Result<User> getUserDetail(String name,String phone) {

      log.info("name:{}",name);

      log.info("phone:{}",phone);

       return  Result.success(null);

    }

}

注：和 Get 请求一样，如果方法形参用 RequestParam 注解标注，表示这个参数需要必传。

2.2 通过 param 提交参数，以实体类接收参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {



    @PostMapping("/save")

    public Result<User> getUserDetail(User user) {

      log.info("name:{}",user.getName());

      log.info("phone:{}",user.getPhone());

       return  Result.success(null);

    }

}

注：Post 请求以实体类接收参数时，不能用 RequestParam 注解进行标注，因为不支持这样的方式获取参数。

2.3 通过 HttpServletRequest 接收参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {



    @PostMapping("/save")

    public Result<User> getUserDetail(HttpServletRequest httpServletRequest) {

      log.info("name:{}",httpServletRequest.getParameter("name"));

      log.info("phone:{}",httpServletRequest.getParameter("phone"));

       return  Result.success(null);

    }

}

2.4 通过 @PathVariable 注解进行接收

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {



    @PostMapping("/save/{name}")

    public Result<User> getUserDetail(@PathVariable String name) {

      log.info("name:{}",name);

       return  Result.success(null);

    }

}

2.5 请求体以 form-data 提交参数，以实体类接收参数

form-data 是表单提交的一种方式，比如常见的登录请求。

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @PostMapping("/save")

    public Result<User> getUserDetail(User user) {

      log.info("name:{}",user.getName());

      log.info("phone:{}",user.getPhone());

       return  Result.success(null);

    }

}

2.6 请求体以 x-www-form-urlencoded 提交参数，以实体类接收参数

x-www-form-urlencoded 也是表单提交的一种方式，只不过提交的参数被进行了编码，并且转换成了键值对。

例如你用form-data 提交的参数：

name: 知否君

age: 22

用 x-www-form-urlencoded 提交的参数：

name=%E5%BC%A0%E4%B8%89&age=22

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @PostMapping("/save")

    public Result<User> getUserDetail(User user) {

      log.info("name:{}",user.getName());

      log.info("phone:{}",user.getPhone());

       return  Result.success(null);

    }

}

2.7 通过 @RequestBody 注解接收参数

注：RequestBody 注解主要用来接收前端传过来的 body 中 json 格式的参数。

2.7.1 接收实体类参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @PostMapping("/save")

    public Result<User> getUserDetail(@RequestBody User user) {

      log.info("name:{}",user.getName());

      log.info("phone:{}",user.getPhone());

       return  Result.success(null);

    }

}

2.7.2 接收数组和集合

接收数组

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @PostMapping("/save")

    public Result<User> getUserDetail(@RequestBody String[] names) {

        Arrays.asList(names).forEach(name->{

            System.out.println(name);

        });

       return  Result.success(null);

    }

}

接收集合

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @PostMapping("/save")

    public Result<User> getUserDetail(@RequestBody List<String> names) {

        names.forEach(name->{

            System.out.println(name);

        });

       return  Result.success(null);

    }

}

2.8 通过 Map 接收参数

1.以 param 方式传参， RequestParam 注解接收参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @PostMapping("/save")

    public Result<User> getUserDetail(@RequestParam Map<String,Object> map) {

        System.out.println(map);

        System.out.println(map.get("name"));

       return  Result.success(null);

    }

}

2.以 body json 格式传参，RequestBody 注解接收参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @PostMapping("/save")

    public Result<User> getUserDetail(@RequestBody Map<String,Object> map) {

        System.out.println(map);

        System.out.println(map.get("name"));

       return  Result.success(null);

    }

}

2.9 RequestBody 接收一个参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @PostMapping("/save")

    public Result<User> getUserDetail(@RequestBody String name) {

        System.out.println(name);

       return  Result.success(null);

    }

}

3. Delete 请求

3.1 以 param 方式传参，以方法形参接收参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @DeleteMapping("/delete")

    public Result<User> getUserDetail(@RequestParam String name) {

        System.out.println(name);

       return  Result.success(null);

    }

}

3.2 以 body json 方式传参，以实体类接收参数

注：需要用 RequestBody 注解，否则接收的参数为 null

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @DeleteMapping("/delete")

    public Result<User> getUserDetail(@RequestBody User user) {

        System.out.println(user);

       return  Result.success(null);

    }

}

3.3 以 body json 方式传参，以 map 接收参数

注：需要用 RequestBody 注解，否则接收的参数为 null

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @DeleteMapping("/delete")

    public Result<User> getUserDetail(@RequestBody Map<String,Object> map) {

        System.out.println(map);

       return  Result.success(null);

    }

}

3.4 PathVariable 接收参数

@RestController

@RequestMapping("/user")

@Slf4j

public class UserController {

    @DeleteMapping("/delete/{name}")

    public Result<User> getUserDetail(@PathVariable String name) {

        System.out.println(name);

       return  Result.success(null);

    }

}

大家好，我是拭心。

最近看到一个很可惜的事：有个阿姨在深圳缴纳了 12 年社保，第 13 年家里突然有事不得不回老家，回去后没再缴纳社保，结果退休后无法领退休工资，还得出来打工赚钱。

之所以这样，是因为阿姨及其家人对退休的相关知识了解不多，痛失一笔收入。

吸取教训，作为在上海工作多年的打工人，为了老有所依，我花了些时间学习了养老金相基本知识，并且估算了一下退休后每月能拿到的钱，这篇文章来聊聊。

文章主要内容：

如何能在上海领退休工资

上海作为全国 GDP 第一的城市，居民的收入也是很可观的。平均工资在 2023 年达到了 12183，平均退休工资在全国也位列前茅：

从上图可以看到，上海的平均退休工资居然有五千多！不用早起不用挤地铁，躺在家里每月就能领五千多，花不完，根本花不完啊！

那么问题来了，我们如何能领到上海的退休工资？

主要有 2 个条件：

第二点很关键：在上海需要缴满社保 10 年，上海 + 其他地方累计需要缴满 15 年。 比如小张在上海工作并缴纳社保满 10 年，然后去青岛缴纳 5 年，最后可以在上海领退休工资；但如果在青岛缴纳了 10 年，在上海缴纳了 5 年，就无法在上海领退休工资了。

需要强调的是，这里说的是「累计缴满」，即使中间有断开也没关系。

还有一个细节是，发工资不等于缴纳社保，个别不正规公司会漏缴社保，这需要我们打工人自己多关注。 身边有朋友遇到过：刚毕业加入的公司规模很小，人力资源不靠谱，干了半年多只缴纳了两个月社保。

怎么看公司有没有给自己缴社保呢？我们可以从随申办上查询：

OK，这就是在上海领退休工资的条件。

退休后大概能领多少钱

掐指一算，社保缴满 15 年的任务我已经完成了一半，但还有二十九年才能领钱，心里苦啊😭。

虽然拿不到，但我对能领多少钱还是非常好奇的，究竟比平均退休工资高还是被平均？🤔

经过一番搜索，我终于发现了退休工资的计算方法。

在国家社会保险公共服务平台网站中，有一个「企业职工养老保险待遇测算」的功能：

国家社会保险公共服务平台 -> 养老保险 -> 企业职工养老保险待遇测算

链接：si.12333.gov.cn/157569.jhtm…

我们只需要输入年龄、预计退休年龄、当前缴纳年限、目前及之前平均工资、养老保险个人账户余额及未来大概工资即可测算退休工资。

如果不知道你的「养老保险个人账户余额」有多少，可以从随申办 app 搜索「养老金」查询余额：

在填完所有需要的信息后，我的预算结果是这样的：

我的天，个十百千万，居然有两万五？这还花的完？？

几秒后冷静下来，我才发现算错了。。。

两万五应该是这样算的：按照当前收入，再连续缴纳 29 年。 😂

对于我们程序员，保持收入 29 年基本是不可能的，我还是重新调整参数再看看吧。

我现在社保缴纳了七年半，如果缴够 15 年社保，退休后我能领多少钱呢？

答案是一万四！看着还不错哈，每天能有 480 元左右，就是不知道 30 年后的物价怎么样了😂。

如果再悲观一点，社保缴纳到 35 岁（然后最低标准缴够 15 年），退休后大概能领多少呢？

答案是一万元！

看了下人民币的贬值率，30 年后的一万元不知道有没有今天三千块钱的购买力😷。

OK，这就是我退休后大概能领到的工资范围。

退休工资的组成

从上面的预算结果中我们可以看到，养老金由三部分组成：基础养老金、个人账户养老金和过渡性养老金，它们都是什么意思呢？

1.基础养老金 = 退休时平均工资 ×（1+平均缴费指数）÷ 2 × 累计缴费年限 × 1%。

退休时平均工资指的是退休时所在地区上年度的社会平均工资。也就是说经济发达地区的基础养老保险金，要高于欠发达地区。

平均缴费指数指的参保人选择的缴纳比例（一般在0.6-3之间）。每个月社保的缴费比例越高，相应的基础养老金越高。

例如，小张退休时，上年度的社会平均工资是 12000。虎虎的缴费指数平均值是 1，累计缴存了15年，他的基础养老金约为：12000*(1+1)/2 * 15 * 1% = 1800。

2.个人账户养老金 = 养老保险个人账户累计金额 ÷ 养老金计发月数。

我们缴纳社保时，一部分会进入个人社保账户，一部分会进入国家统筹账户。个人账户的部分，直接影响退休养老金的计算。

计发月数和我们退休的年龄有直接的关系，退休的越晚，计发月数越少；退休的时间越早，计发月数越多。一般来说，按照 60岁 退休，计发月数是 139 个月。

退休金的计发月数只是用来计算退休金，而不是说只能领这么久的退休金。

例如，小张社保的个人缴纳比例为 8%，社保的计算基数是 9339，他选择在 60 岁退休，那他的个人账户养老金约为：9339 * 8% * 12 * 15 / 139 = 967.49。

3.过渡性养老金 = 退休时平均工资 × 建立个人账户前的缴费年限 × 1.3% × 平均缴费指数

过渡性养老金，是指在养老保险制度发生变化（比如缴费标准提高、计算方法改变、退休年龄调整）的时候，给予受影响群体的资金补充。

这个奖金的计算规则说法不一，一种比较广泛的计算方法是：退休时所在地区的平均工资 x 缴费指数 x 缴费年限 x 过渡系数，其中过渡系数大概在 1% 到 1.4% 之间。

OK，这就是养老金三部分组成的含义。

总结

好了，这篇文章到这里就结束了，主要讲了：

通过写这篇文章，我对养老金的认识更多了一些，希望国家繁荣昌盛，让我退休的时候能多领点钱!

下面看一下改版后的滑块验证码：

我在文章的评论区看到了一些关于这次升级或相关的讨论：

本文将继续破解这次升级后的滑块验证码，看看这次升级对破解的难度有多大影响，如果你还没有了解过如何破解滑块验证码，请先看我之前的文章。

iframe

这次升级，整个滑块都掉用的是外部链接，使用 iframe 呈现，那么在 puppeteer 中如何处理呢？

await page.waitForSelector('iframe');

const elementHandle = await page.$('iframe');

const frame = await elementHandle.contentFrame();

实际上，我们只需要等待 iframe 加载完成，然后获取 iframe 的内容即可。

Frame 对象和 Page 对象有很多相似的方法，比如 frame.$、frame.evaluate 等，我们可以直接使用这些方法来操作 iframe 中的元素。

验证码的识别

上一篇文章采用比较简单的判断方式，当时缺口处有明显的白边，所以只需要找到这个白边即可。

但是本次升级后，缺口不再是白边，而是阴影的效果，并且缺口的形状也不再是拼图，大概率都是曲线的边，所以再判断缺口的方式就不再适用了。

现在我们可以采用一种新的方式，通过对比滑块图片和缺口区域的像素值相似程度来判断缺口位置。

首先还是二值化处理，将图片转换为黑白两色：

可以看到左侧缺口和右侧缺口非常相似，只是做了一点旋转作为干扰。

再看一下，iframe 中还有一个很重要的东西，就是校验的图片：

它是一个 png 图片，所以我们可以把它也转换成二值化，简单的方式就是将透明色转换为白色，非透明色转换为黑色，如果想提高识别精度，可以与背景图一样，通过灰度、二值化的转换方式。

// 获取缺口图像

const captchaVerifyImage = document.querySelector(

  '#captcha-verify_img_slide',

) as HTMLImageElement;

// 创建一个画布，将 image 转换成canvas

const captchaCanvas = document.createElement('canvas');

captchaCanvas.width = captchaVerifyImage.width;

captchaCanvas.height = captchaVerifyImage.height;

const captchaCtx = captchaCanvas.getContext('2d');

captchaCtx.drawImage(

  captchaVerifyImage,

  0,

  0,

  captchaVerifyImage.width,

  captchaVerifyImage.height,

);

const captchaImageData = captchaCtx.getImageData(

  0,

  0,

  captchaVerifyImage.width,

  captchaVerifyImage.height,

);

// 将像素数据转换为二维数组，同样处理灰度、二值化，将像素点转换为0（黑色）或1（白色）

const captchaData: number[][] = [];

for (let h = 0; h < captchaVerifyImage.height; h++) {

  captchaData.push([]);

  for (let w = 0; w < captchaVerifyImage.width; w++) {

    const index = (h * captchaVerifyImage.width + w) * 4;

    const r = captchaImageData.data[index] * 0.2126;

    const g = captchaImageData.data[index + 1] * 0.7152;

    const b = captchaImageData.data[index + 2] * 0.0722;

    if (r + g + b > 30) {

      captchaData[h].push(0);

    } else {

      captchaData[h].push(1);

    }

  }

}