MySQL 高级（进阶）SQL 语句

1. MySQL SQL 语句

1.1 常用查询

常用查询简单来说就是 增、删、改、查

对 MySQL 数据库的查询，除了基本的查询外，有时候需要对查询的结果集进行处理。 例如只取 10 条数据、对查询结果进行排序或分组等等

1、按关键字排序
PS:类比于windows 任务管理器
使用 SELECT 语句可以将需要的数据从 MySQL 数据库中查询出来，如果对查询的结果进行排序，可以使用 ORDER BY 语句来对语句实现排序，并最终将排序后的结果返回给用户。这个语句的排序不光可以针对某一个字段，也可以针对多个字段

（1）语法
SELECT column1, column2, … FROM table_name ORDER BY column1, column2, …

ASC|DESC
ASC 是按照升序进行排序的，是默认的排序方式，即 ASC 可以省略。SELECT 语句中如果没有指定具体的排序方式，则默认按 ASC方式进行排序。

DESC 是按降序方式进 行排列。当然 ORDER BY 前面也可以使用 WHERE 子句对查询结果进一步过滤。

准备工作：

create database k1;

use k1;

create table location (Region char(20),Store_Name char(20));

insert int0 location values('East','Boston');

insert int0 location values('East','New York');

insert int0 location values('West','Los Angeles');

insert int0 location values('West','Houston');

create table store_info (Store_Name char(20),Sales int(10),Date char(10));

insert int0 store_info values('Los Angeles','1500','2020-12-05');

insert int0 store_info values('Houston','250','2020-12-07');

insert int0 store_info values('Los Angeles','300','2020-12-08');

insert int0 store_info values('Boston','700','2020-12-08');

1.2 SELECT

显示表格中一个或数个字段的所有数据记录 语法：SELECT "字段" FROM "表名";

SELECT Store_Name FROM location;

SELECT Store_Name FROM Store_Info;

1.3 DISTINCT

不显示重复的数据记录

语法：SELECT DISTINCT "字段" FROM "表名";

SELECT DISTINCT Store_Name FROM Store_Info;

1.4 AND OR

且 或

语法：SELECT "字段" FROM "表名" WHERE "条件1" {[AND|OR] "条件2"}+ ;

1.5 in

显示已知的值的数据记录

语法：SELECT "字段" FROM "表名" WHERE "字段" IN ('值1', '值2', ...);

SELECT * FROM store_info WHERE Store_Name IN ('Los Angeles', 'Houston');

1.6 BETWEEN

显示两个值范围内的数据记录

语法：SELECT "字段" FROM "表名" WHERE "字段" BETWEEN '值1' AND '值2';

2. 通配符 —— 通常与 LIKE 搭配 一起使用

% ：百分号表示零个、一个或多个字符

_ ：下划线表示单个字符

'A_Z'：所有以 'A' 起头，另一个任何值的字符，且以 'Z' 为结尾的字符串。例如，'ABZ' 和 'A2Z' 都符合这一个模式，而 'AKKZ' 并不符合 (因为在 A 和 Z 之间有两个字符，而不是一个字符)。

'ABC%': 所有以 'ABC' 起头的字符串。例如，'ABCD' 和 'ABCABC' 都符合这个模式。 '%XYZ': 所有以 'XYZ' 结尾的字符串。例如，'WXYZ' 和 'ZZXYZ' 都符合这个模式。

'%AN%': 所有含有 'AN'这个模式的字符串。例如，'LOS ANGELES' 和 'SAN FRANCISCO' 都符合这个模式。

'_AN%'：所有第二个字母为 'A' 和第三个字母为 'N' 的字符串。例如，'SAN FRANCISCO' 符合这个模式，而 'LOS ANGELES' 则不符合这个模式。

2.1 LIKE

匹配一个模式来找出我们要的数据记录

语法：SELECT "字段" FROM "表名" WHERE "字段" LIKE {模式};

SELECT * FROM store_info WHERE Store_Name like '%os%';

2.2 ORDER BY

按关键字排序

语法：SELECT "字段" FROM "表名" [WHERE "条件"] ORDER BY "字段" [ASC, DESC];

注意：ASC 是按照升序进行排序的，是默认的排序方式。 DESC 是按降序方式进行排序

SELECT Store_Name,Sales,Date FROM store_info ORDER BY Sales DESC;

3. 函数

3.1数学函数

SELECT abs(-1), rand(), mod(5,3), power(2,3), round(1.89);

SELECT round(1.8937,3), truncate(1.235,2), ceil(5.2), floor(2.1), least(1.89,3,6.1,2.1);

3.2 聚合函数

SELECT avg(Sales) FROM store_info;



SELECT count(Store_Name) FROM store_info;

SELECT count(DISTINCT Store_Name) FROM store_info;



SELECT max(Sales) FROM store_info;

SELECT min(Sales) FROM store_info;



SELECT sum(Sales) FROM store_info;

3.3 字符串函数

如 sql_mode 开启了 PIPES_AS_CONCAT，"||" 视为字符串的连接操作符而非或运算符，和字符串的拼接函数Concat相类似，这和Oracle数据库使用方法一样的

SELECT Region || ' ' || Store_Name FROM location WHERE Store_Name = 'Boston';

SELECT substr(Store_Name,3) FROM location WHERE Store_Name = 'Los Angeles';

SELECT substr(Store_Name,2,4) FROM location WHERE Store_Name = 'New York'

SELECT TRIM ([ [位置] [要移除的字符串] FROM ] 字符串);

**[位置]：的值可以为 LEADING (起头), TRAILING (结尾), BOTH (起头及结尾)。 **

[要移除的字符串]：从字串的起头、结尾，或起头及结尾移除的字符串。缺省时为空格。

SELECT TRIM(LEADING 'Ne' FROM 'New York');

 

SELECT Region,length(Store_Name) FROM location;

 

SELECT REPLACE(Region,'ast','astern')FROM location;

4. GR0UP BY

对GR0UP BY后面的字段的查询结果进行汇总分组，通常是结合聚合函数一起使用的

GR0UP BY 有一个原则

• 凡是在 GR0UP BY 后面出现的字段，必须在 SELECT 后面出现；


• 凡是在 SELECT 后面出现的、且未在聚合函数中出现的字段，必须出现在 GR0UP BY 后面

语法：SELECT "字段1", SUM("字段2") FROM "表名" GR0UP BY "字段1";

SELECT Store_Name, SUM(Sales) FROM store_info GR0UP BY Store_Name ORDER BY sales desc;

5. 别名

字段別名 表格別名

语法：SELECT "表格別名"."字段1" [AS] "字段別名" FROM "表格名" [AS] "表格別名";

SELECT A.Store_Name Store, SUM(A.Sales) "Total Sales" FROM store_info A GR0UP BY A.Store_Name;

6. 子查询

子查询也被称作内查询或者嵌套查询，是指在一个查询语句里面还嵌套着另一个查询语 句。子查询语句是先于主查询语句被执行的，其结果作为外层的条件返回给主查询进行下一 步的查询过滤

连接表格，在WHERE 子句或 HAVING 子句中插入另一个 SQL 语句

语法：SELECT "字段1" FROM "表格1" WHERE "字段2" [比较运算符] #外查询 (SELECT "字段1" FROM "表格2" WHERE "条件"); #内查询

[比较运算符]

可以是符号的运算符，例如 =、>、<、>=、<= ；也可以是文字的运算符，例如 LIKE、IN、BETWEEN

SELECT SUM(Sales) FROM store_info WHERE Store_Name IN

(SELECT Store_Name FROM location WHERE Region = 'West');



SELECT SUM(A.Sales) FROM store_info A WHERE A.Store_Name IN

(SELECT Store_Name FROM location B WHERE B.Store_Name = A.Store_Name);

7. EXISTS

用来测试内查询有没有产生任何结果，类似布尔值是否为真 #如果有的话，系统就会执行外查询中的SQL语句。若是没有的话，那整个 SQL 语句就不会产生任何结果。

语法：SELECT "字段1" FROM "表格1" WHERE EXISTS (SELECT \* FROM "表格2" WHERE "条件");

SELECT SUM(Sales) FROM store_info WHERE EXISTS (SELECT * FROM location WHERE Region = 'West');

8. 连接查询

准备工作

create database k1;

use k1;

create table location (Region char(20),Store_Name char(20));

insert int0 location values('East','Boston');

insert int0 location values('East','New York');

insert int0 location values('West','Los Angeles');

insert int0 location values('West','Houston');

create table store_info (Store_Name char(20),Sales int(10),Date char(10));

insert int0 store_info values('Los Angeles','1500','2020-12-05');

insert int0 store_info values('Houston','250','2020-12-07');

insert int0 store_info values('Los Angeles','300','2020-12-08');

insert int0 store_info values('Boston','700','2020-12-08');

UPDATE store_info SET store_name='Washington' WHERE sales=300;

inner join(内连接)：只返回两个表中联结字段相等的行

left join(左连接)：返回包括左表中的所有记录和右表中联结字段相等的记录

right join(右连接)：返回包括右表中的所有记录和左表中联结字段相等的记录

8.1 内连接

MySQL 中的内连接就是两张或多张表中同时符合某种条件的数据记录的组合。通常在 FROM 子句中使用关键字 INNER JOIN 来连接多张表，并使用 ON 子句设置连接条件，内连接是系统默认的表连接，所以在 FROM 子句后可以省略 INNER 关键字，只使用 关键字 JOIN。同时有多个表时，也可以连续使用 INNER JOIN 来实现多表的内连接，不过为了更好的性能，建议最好不要超过三个表

(1) 语法 求交集

SELECT column_name(s)FROM table1 INNER JOIN table2 ON table1.column_name = table2.column_name;

SELECT * FROM location A INNER JOIN store_info B on A.Store_Name = B.Store_Name ;

内连查询：通过inner join 的方式将两张表指定的相同字段的记录行输出出来

8.2 左连接

左连接也可以被称为左外连接，在 FROM 子句中使用 LEFT JOIN 或者 LEFT OUTER JOIN 关键字来表示。左连接以左侧表为基础表，接收左表的所有行，并用这些行与右侧参 考表中的记录进行匹配，也就是说匹配左表中的所有行以及右表中符合条件的行。

SELECT * FROM location A LEFT JOIN store_info B on A.Store_Name = B.Store_Name ;

左连接中左表的记录将会全部表示出来，而右表只会显示符合搜索条件的记录，右表记录不足的地方均为 NULL

8.3 右连接

右连接也被称为右外连接，在 FROM 子句中使用 RIGHT JOIN 或者 RIGHT OUTER JOIN 关键字来表示。右连接跟左连接正好相反，它是以右表为基础表，用于接收右表中的所有行，并用这些记录与左表中的行进行匹配

SELECT * FROM location A RIGHT JOIN store_info B on A.Store_Name = B.Store_Name ;

9. UNION ----联集

将两个SQL语句的结果合并起来，两个SQL语句所产生的字段需要是同样的数据记录种类

UNION ：生成结果的数据记录值将没有重复，且按照字段的顺序进行排序

语法：[SELECT 语句 1] UNION [SELECT 语句 2];

SELECT Store_Name FROM location UNION SELECT Store_Name FROM store_info;

UNION ALL ：将生成结果的数据记录值都列出来，无论有无重复

语法：[SELECT 语句 1] UNION ALL [SELECT 语句 2];

SELECT Store_Name FROM location UNION ALL SELECT Store_Name FROM store_info;

9.1 交集值

取两个SQL语句结果的交集

SELECT A.Store_Name FROM location A INNER JOIN store_info B ON A.Store_Name = B.Store_Name;



SELECT A.Store_Name FROM location A INNER JOIN store_info B USING(Store_Name);

取两个SQL语句结果的交集，且没有重复

SELECT DISTINCT A.Store_Name FROM location A INNER JOIN store_info B USING(Store_Name);



SELECT DISTINCT Store_Name FROM location WHERE (Store_Name) IN (SELECT Store_Name FROM store_info);



SELECT DISTINCT A.Store_Name FROM location A LEFT JOIN store_info B USING(Store_Name) WHERE B.Store_Name IS NOT NULL;



SELECT A.Store_Name FROM (SELECT B.Store_Name FROM location B INNER JOIN store_info C ON B.Store_Name = C.Store_Name) A 

GR0UP BY A.Store_Name;



SELECT A.Store_Name FROM 

(SELECT DISTINCT Store_Name FROM location UNION ALL SELECT DISTINCT Store_Name FROM store_info) A 

GR0UP BY A.Store_Name HAVING COUNT(*) > 1;

9.2 无交集值

显示第一个SQL语句的结果，且与第二个SQL语句没有交集的结果，且没有重复

SELECT DISTINCT Store_Name FROM location WHERE (Store_Name) NOT IN (SELECT Store_Name FROM store_info);



SELECT DISTINCT A.Store_Name FROM location A LEFT JOIN store_info B USING(Store_Name) WHERE B.Store_Name IS NULL;



SELECT A.Store_Name FROM 

(SELECT DISTINCT Store_Name FROM location UNION ALL SELECT DISTINCT Store_Name FROM store_info) A 

GR0UP BY A.Store_Name HAVING COUNT(*) = 1;

10. case

是 SQL 用来做为 IF-THEN-ELSE 之类逻辑的关键字

语法：

SELECT CASE ("字段名")

  WHEN "条件1" THEN "结果1"

  WHEN "条件2" THEN "结果2"

  ...

  [ELSE "结果N"]

  END

FROM "表名";

"条件" 可以是一个数值或是公式。 ELSE 子句则并不是必须的。

SELECT Store_Name, CASE Store_Name 

  WHEN 'Los Angeles' THEN Sales * 2 

  WHEN 'Boston' THEN 2000

  ELSE Sales 

  END 

"New Sales",Date 

FROM store_info;



#"New Sales" 是用于 CASE 那个字段的字段名。

11. 正则表达式

语法：SELECT "字段" FROM "表名" WHERE "字段" REGEXP {模式};

SELECT * FROM store_info WHERE Store_Name REGEXP 'os';

SELECT * FROM store_info WHERE Store_Name REGEXP '^[A-G]';

SELECT * FROM store_info WHERE Store_Name REGEXP 'Ho|Bo';

12. 存储过程

存储过程是一组为了完成特定功能的SQL语句集合。

存储过程在使用过程中是将常用或者复杂的工作预先使用SQL语句写好并用一个指定的名称存储起来，这个过程经编译和优化后存储在数据库服务器中。当需要使用该存储过程时，只需要调用它即可。存储过程在执行上比传统SQL速度更快、执行效率更高。

存储过程的优点：

1、执行一次后，会将生成的二进制代码驻留缓冲区，提高执行效率

2、SQL语句加上控制语句的集合，灵活性高

3、在服务器端存储，客户端调用时，降低网络负载

4、可多次重复被调用，可随时修改，不影响客户端调用

5、可完成所有的数据库操作，也可控制数据库的信息访问权限

12.1 创建存储过程

DELIMITER $$							#将语句的结束符号从分号;临时改为两个$$(可以是自定义)

CREATE PROCEDURE Proc()					#创建存储过程，过程名为Proc，不带参数

-> BEGIN								#过程体以关键字 BEGIN 开始

-> select * from Store_Info;			#过程体语句

-> END $$								#过程体以关键字 END 结束

DELIMITER ;								#将语句的结束符号恢复为分号

实例

DELIMITER $$							#将语句的结束符号从分号;临时改为两个$$(可以自定义)

CREATE PROCEDURE Proc5()				#创建存储过程，过程名为Proc5，不带参数

-> BEGIN								#过程体以关键字 BEGIN 开始

-> create table user (id int (10), name char(10),score int (10));

-> insert int0 user values (1, 'cyw',70);

-> select * from cyw;			        #过程体语句

-> END $$								#过程体以关键字 END 结束

DELIMITER ;								#将语句的结束符号恢复为分号

12.2 调用存储过程

CALL Proc;

12.3 查看存储过程

SHOW CREATE PROCEDURE [数据库.]存储过程名; #查看某个存储过程的具体信息

SHOW CREATE PROCEDURE Proc;



SHOW PROCEDURE STATUS [LIKE '%Proc%'] \G

12.4 存储过程的参数

**IN 输入参数：**表示调用者向过程传入值（传入值可以是字面量或变量）

**OUT 输出参数：**表示过程向调用者传出值(可以返回多个值)（传出值只能是变量）

**INOUT 输入输出参数：**既表示调用者向过程传入值，又表示过程向调用者传出值（值只能是变量）

DELIMITER $$				

CREATE PROCEDURE Proc6(IN inname CHAR(16))		

-> BEGIN					

-> SELECT * FROM store_info WHERE Store_Name = inname;

-> END $$					

DELIMITER ;					



CALL Proc6('Boston');

12.5 修改存储过程

ALTER PROCEDURE <过程名>[<特征>... ]

ALTER PROCEDURE GetRole MODIFIES SQL DATA SQL SECURITY INVOKER;

MODIFIES sQLDATA:表明子程序包含写数据的语句

SECURITY:安全等级

invoker:当定义为INVOKER时，只要执行者有执行权限，就可以成功执行。

12.6 删除存储过程

存储过程内容的修改方法是通过删除原有存储过程，之后再以相同的名称创建新的存储过程。如果要修改存储过程的名称，可以先删除原存储过程，再以不同的命名创建新的存储过程。

DROP PROCEDURE IF EXISTS Proc;		

#仅当存在时删除，不添加 IF EXISTS 时，如果指定的过程不存在，则产生一个错误

13. 条件语句

if-then-else ···· end if

mysql> delimiter $$

mysql> 

mysql> CREATE PROCEDURE proc8(IN pro int)

    -> 

    -> begin

    -> 

    -> declare var int; 

    -> set var=pro*2;

    -> if var>=10 then 

    -> update t set id=id+1;

    -> else

    -> update t set id=id-1;

    -> end if;

    -> end $$



mysql> delimiter ;

14. 循环语句

while ···· end while

mysql> delimiter $$

mysql> 

mysql> create procedure proc9()

    -> begin 

    -> declare var int(10);  

    -> set var=0;

    -> while var<6 do 

    -> insert int0 t values(var);

    -> set var=var+1;

    -> end while;

    -> end $$ 



mysql> delimiter ;

15. 视图表 create view

15.1 视图表概述

视图，可以被当作是虚拟表或存储查询。

视图跟表格的不同是，表格中有实际储存数据记录，而视图是建立在表格之上的一个架构，它本身并不实际储存数据记录。

临时表在用户退出或同数据库的连接断开后就自动消失了，而视图不会消失。
视图不含有数据，只存储它的定义，它的用途一般可以简化复杂的查询。

比如你要对几个表进行连接查询，而且还要进行统计排序等操作，写sql语句会很麻烦的，用视图将几个表联结起来，然后对这个视图进行查询操作，就和对一个表查询一样，很方便。

15.2 视图表能否修改？

首先我们需要知道，视图表保存的是select语句的定义，所以视图表可不可以修改需要视情况而定。

• 如果 select 语句查询的字段是没有被处理过的源表字段，则可以通过视图表修改源表数据；


• 如果select 语句查询的字段是被 gr0up by语句或 函数 处理过的字段，则不可以直接修改视图表的数据。

create view v_store_info as select store_name,sales from store_info;



update v_store_info set sales=1000 where store_name='Houston';

create view v_sales as select store_name,sum(sales) from store_info gr0up by store_name having sum(sales)>1000;



update v_sales set store_name='xxxx' where store_name='Los Angeles';

15.3 基本语法

15.3.1 创建视图表

语法

create view "视图表名" as "select 语句";

create view v_region_sales as select a.region region,sum(b.sales) sales from location a 

inner join store_info b on a.store_name = b.store_name gr0up by region;

15.4 查看视图表

语法

select * from 视图表名;

select * from v_region_sales;

15.5 删除视图表

语法

drop view 视图表名;

drop view v_region_sales;

15.6 通过视图表求无交集值

将两个表中某个字段的不重复值进行合并

只出现一次（count =1 ） ，即无交集

通过

create view 视图表名 as select distinct 字段 from 左表 union all select distinct 字段 from 右表;



select 字段 from 视图表名 gr0up by 字段 having count(字段)=1;

#先建立视图表

create viem v_union as select distinct store_name from location union all select distinct store_name from store_info;

#再通过视图表求无交集

select store_name from v_union gr0up by store_name having count(*)=1;

大家好，我是三友~~

今天就应某位小伙伴的要求，来讲一讲Nacos作为服务注册中心底层的实现原理

不知你是否跟我一样，在使用Nacos时有以下几点疑问：

• 临时实例和永久实例是什么？有什么区别？


• 服务实例是如何注册到服务端的？


• 服务实例和服务端之间是如何保活的？


• 服务订阅是如何实现的？


• 集群间数据是如何同步的？CP还是AP？


• Nacos的数据模型是什么样的？


• ...

本文就通过探讨上述问题来探秘Nacos服务注册中心核心的底层实现原理。

虽然Nacos最新版本已经到了2.x版本，但是为了照顾那些还在用1.x版本的同学，所以本文我会同时去讲1.x版本和2.x版本的实现

临时实例和永久实例

临时实例和永久实例在Nacos中是一个非常非常重要的概念

之所以说它重要，主要是因为我在读源码的时候发现，临时实例和永久实例在底层的许多实现机制是完全不同的

临时实例

临时实例在注册到注册中心之后仅仅只保存在服务端内部一个缓存中，不会持久化到磁盘

这个服务端内部的缓存在注册中心届一般被称为服务注册表

当服务实例出现异常或者下线之后，就会把这个服务实例从服务注册表中剔除

永久实例

永久服务实例不仅仅会存在服务注册表中，同时也会被持久化到磁盘文件中

当服务实例出现异常或者下线，Nacos只会将服务实例的健康状态设置为不健康，并不会对将其从服务注册表中剔除

所以这个服务实例的信息你还是可以从注册中心看到，只不过处于不健康状态

这是就是两者最最最基本的区别

当然除了上述最基本的区别之外，两者还有很多其它的区别，接下来本文还会提到

这里你可能会有一个疑问

为什么Nacos要将服务实例分为临时实例和永久实例?

主要还是因为应用场景不同

临时实例就比较适合于业务服务，服务下线之后可以不需要在注册中心中查看到

永久实例就比较适合需要运维的服务，这种服务几乎是永久存在的，比如说MySQL、Redis等等

MySQL、Redis等服务实例可以通过SDK手动注册

对于这些服务，我们需要一直看到服务实例的状态，即使出现异常，也需要能够查看时实的状态

所以从这可以看出Nacos跟你印象中的注册中心不太一样，他不仅仅可以注册平时业务中的实例，还可以注册像MySQL、Redis这个服务实例的信息到注册中心

在SpringCloud环境底下，一般其实都是业务服务，所以默认注册服务实例都是临时实例

当然如果你想改成永久实例，可以通过下面这个配置项来完成

spring

  cloud:

    nacos:

      discovery:

        #ephemeral单词是临时的意思，设置成false，就是永久实例了

        ephemeral: false

这里还有一个小细节

在1.x版本中，一个服务中可以既有临时实例也有永久实例，服务实例是永久还是临时是由服务实例本身决定的

但是2.x版本中，一个服务中的所有实例要么都是临时的要么都是永久的，是由服务决定的，而不是具体的服务实例

所以在2.x可以说是临时服务和永久服务

为什么2.x把临时还是永久的属性由实例本身决定改成了由服务决定?

其实很简单，你想想，假设对一个MySQL服务来说，它的每个服务实例肯定都是永久的，不会出现一些是永久的，一些是临时的情况吧

所以临时还是永久的属性由服务本身决定其实就更加合理了

服务注册

作为一个服务注册中心，服务注册肯定是一个非常重要的功能

所谓的服务注册，就是通过注册中心提供的客户端SDK（或者是控制台）将服务本身的一些元信息，比如ip、端口等信息发送到注册中心服务端

服务端在接收到服务之后，会将服务的信息保存到前面提到的服务注册表中

1、1.x版本的实现

在Nacos在1.x版本的时候，服务注册是通过Http接口实现的

代码如下

整个逻辑比较简单，因为Nacos服务端本身就是用SpringBoot写的

但是在2.x版本的实现就比较复杂了

2、2.x版本的实现

2.1、通信协议的改变

2.x版本相比于1.x版本最主要的升级就是客户端和服务端通信协议的改变，由1.x版本的Http改成了2.x版本gRPC

gRPC是谷歌公司开发的一个高性能、开源和通用的RPC框架，Java版本的实现底层也是基于Netty来的

之所以改成了gRPC，主要是因为Http请求会频繁创建和销毁连接，白白浪费资源

所以在2.x版本之后，为了提升性能，就将通信协议改成了gRPC

根据官网显示，整体的效果还是很明显，相比于1.x版本，注册性能总体提升至少2倍

虽然通信方式改成了gRPC，但是2.x版本服务端依然保留了Http注册的接口，所以用1.x的Nacos SDK依然可以注册到2.x版本的服务端

2.2、具体的实现

Nacos客户端在启动的时候，会通过gRPC跟服务端建立长连接

这个连接会一直存在，之后客户端与服务端所有的通信都是基于这个长连接来的

当客户端发起注册的时候，就会通过这个长连接，将服务实例的信息发送给服务端

服务端拿到服务实例，跟1.x一样，也会存到服务注册表

除了注册之外，当注册的是临时实例时，2.x还会将服务实例信息存储到客户端中的一个缓存中，供Redo操作

所谓的Redo操作，其实就是一个补偿机制，本质是个定时任务，默认每3s执行一次

这个定时任务作用是，当客户端与服务端重新建立连接时（因为一些异常原因导致连接断开）

那么之前注册的服务实例肯定还要继续注册服务端（断开连接服务实例就会被剔除服务注册表）

所以这个Redo操作一个很重要的作用就是重连之后的重新注册的作用

除了注册之外，比如服务订阅之类的操作也需要Redo操作，当连接重新建立，之前客户端的操作都需要Redo一下

小总结

1.x版本是通过Http协议来进行服务注册的

2.x由于客户端与服务端的通信改成了gRPC长连接，所以改成通过gRPC长连接来注册

2.x比1.x多个Redo操作，当注册的服务实例是临时实例是，出现网络异常，连接重新建立之后，客户端需要将服务注册、服务订阅之类的操作进行重做

这里你可能会有个疑问

既然2.x有Redo机制保证客户端与服务端通信正常之后重新注册，那么1.x有类似的这种Redo机制么？

当然也会有，接下往下看。

心跳机制

心跳机制，也可以被称为保活机制，它的作用就是服务实例告诉注册中心我这个服务实例还活着

在正常情况下，服务关闭了，那么服务会主动向Nacos服务端发送一个服务下线的请求

Nacos服务端在接收到请求之后，会将这个服务实例从服务注册表中剔除

但是对于异常情况下，比如出现网络问题，可能导致这个注册的服务实例无法提供服务，处于不可用状态，也就是不健康

而此时在没有任何机制的情况下，服务端是无法知道这个服务处于不可用状态

所以为了避免这种情况，一些注册中心，就比如Nacos、Eureka，就会用心跳机制来判断这个服务实例是否能正常

在Nacos中，心跳机制仅仅是针对临时实例来说的，临时实例需要靠心跳机制来保活

心跳机制在1.x和2.x版本的实现也是不一样的

1.x心跳实现

在1.x中，心跳机制实现是通过客户端和服务端各存在的一个定时任务来完成的

在服务注册时，发现是临时实例，客户端会开启一个5s执行一次的定时任务

这个定时任务会构建一个Http请求，携带这个服务实例的信息，然后发送到服务端

在Nacos服务端也会开启一个定时任务，默认也是5s执行一次，去检查这些服务实例最后一次心跳的时间，也就是客户端最后一次发送Http请求的时间

• 当最后一次心跳时间超过15s，但没有超过30s，会把这服务实例标记成不健康


• 当最后一次心跳超过30s，直接把服务从服务注册表中剔除

这就是1.x版本的心跳机制，本质就是两个定时任务

其实1.x的这个心跳还有一个作用，就是跟上一节说的gRPC时Redo操作的作用是一样的

服务在处理心跳的时候，发现心跳携带这个服务实例的信息在注册表中没有，此时就会添加到服务注册表

所以心跳也有Redo的类似效果

2.x心跳实现

在2.x版本之后，由于通信协议改成了gRPC，客户端与服务端保持长连接，所以2.x版本之后它是利用这个gRPC长连接本身的心跳来保活

一旦这个连接断开，服务端就会认为这个连接注册的服务实例不可用，之后就会将这个服务实例从服务注册表中提出剔除

除了连接本身的心跳之外，Nacos还有服务端的一个主动检测机制

Nacos服务端也会启动一个定时任务，默认每隔3s执行一次

这个任务会去检查超过20s没有发送请求数据的连接

一旦发现有连接已经超过20s没发送请求，那么就会向这个连接对应的客户端发送一个请求

如果请求不通或者响应失败，此时服务端也会认为与客户端的这个连接异常，从而将这个客户端注册的服务实例从服务注册表中剔除

所以对于2.x版本，主要是两种机制来进行保活：

• 连接本身的心跳机制，断开就直接剔除服务实例


• Nacos主动检查机制，服务端会对20s没有发送数据的连接进行检查，出现异常时也会主动断开连接，剔除服务实例

小总结

心跳机制仅仅针对临时实例而言

1.x心跳机制是通过客户端和服务端两个定时任务来完成的，客户端定时上报心跳信息，服务端定时检查心跳时间，超过15s标记不健康，超过30s直接剔除

1.x心跳机制还有类似2.x的Redo作用，服务端发现心跳的服务信息不存在会，会将服务信息添加到注册表，相当于重新注册了

2.x是基于gRPC长连接本身的心跳机制和服务端的定时检查机制来的，出现异常直接剔除

健康检查

前面说了，心跳机制仅仅是临时实例用来保护的机制

而对于永久实例来说，一般来说无法主动上报心跳

就比如说MySQL实例，肯定是不会主动上报心跳到Nacos的，所以这就导致无法通过心跳机制来保活

所以针对永久实例的情况，Nacos通过一种叫健康检查的机制去判断服务实例是否活着

健康检查跟心跳机制刚好相反，心跳机制是服务实例向服务端发送请求

而所谓的健康检查就是服务端主动向服务实例发送请求，去探测服务实例是否活着

健康检查机制在1.x和2.x的实现机制是一样的

Nacos服务端在会去创建一个健康检查任务，这个任务每次执行时间间隔会在2000~7000毫秒之间

当任务触发的时候，会根据设置的健康检查的方式执行不同的逻辑，目前主要有以下三种方式：

• TCP


• HTTP


• MySQL

TCP的方式就是根据服务实例的ip和端口去判断是否能连接成功，如果连接成功，就认为健康，反之就任务不健康

HTTP的方式就是向服务实例的ip和端口发送一个Http请求，请求路径是需要设置的，如果能正常请求，说明实例健康，反之就不健康

MySQL的方式是一种特殊的检查方式，他可以执行下面这条Sql来判断数据库是不是主库

默认情况下，都是通过TCP的方式来探测服务实例是否还活着

服务发现

所谓的服务发现就是指当有服务实例注册成功之后，其它服务可以发现这些服务实例

Nacos提供了两种发现方式：

• 主动查询


• 服务订阅

主动查询就是指客户端主动向服务端查询需要关注的服务实例，也就是拉（pull）的模式

服务订阅就是指客户端向服务端发送一个订阅服务的请求，当被订阅的服务有信息变动就会主动将服务实例的信息推送给订阅的客户端，本质就是推（push）模式

在我们平时使用时，一般来说都是选择使用订阅的方式，这样一旦有服务实例数据的变动，客户端能够第一时间感知

并且Nacos在整合SpringCloud的时候，默认就是使用订阅的方式

对于这两种服务发现方式，1.x和2.x版本实现也是不一样

服务查询其实两者实现都很简单

1.x整体就是发送Http请求去查询服务实例，2.x只不过是将Http请求换成了gRPC的请求

服务端对于查询的处理过程都是一样的，从服务注册表中查出符合查询条件的服务实例进行返回

不过对于服务订阅，两者的机制就稍微复杂一点

在Nacos客户端，不论是1.x还是2.x都是通过SDK中的NamingService#subscribe方法来发起订阅的

当有服务实例数据变动的时，客户端就会回调EventListener，就可以拿到最新的服务实例数据了

虽然1.x还是2.x都是同样的方法，但是具体的实现逻辑是不一样的

1.x服务订阅实现

在1.x版本的时候，服务订阅的处理逻辑大致会有以下三步：

第一步，客户端在启动的时候，会去构建一个叫PushReceiver的类

这个类会去创建一个UDP Socket，端口是随机的

其实通过名字就可以知道这个类的作用，就是通过UDP的方式接收服务端推送的数据的

第二步，调用NamingService#subscribe来发起订阅时，会先去服务端查询需要订阅服务的所有实例信息

之后会将所有服务实例数据存到客户端的一个内部缓存中

并且在查询的时候，会将这个UDP Socket的端口作为一个参数传到服务端

服务端接收到这个UDP端口后，后续就通过这个端口给客户端推送服务实例数据

第三步，会为这次订阅开启一个不定时执行的任务

之所以不定时，是因为这个当执行异常的时候，下次执行的时间间隔就会变长，但是最多不超过60s，正常是10s，这个10s是查询服务实例是服务端返回的

这个任务会去从服务端查询订阅的服务实例信息，然后更新内部缓存

这里你可能会有个疑问

既然有了服务变动推送的功能，为什么还要定时去查询更新服务实例信息呢?

其实很简单，那就是因为UDP通信不稳定导致的

虽然有Push，但是由于UDP通信自身的不确定性，有可能会导致客户端接收变动信息失败

所以这里就加了一个定时任务，弥补这种可能性，属于一个兜底的方案。

这就是1.x版本的服务订阅的实现

2.x服务订阅的实现

讲完1.x的版本实现，接下来就讲一讲2.x版本的实现

由于2.x版本换成了gRPC长连接的方式，所以2.x版本服务数据变更推送已经完全抛弃了1.x的UDP做法

当有服务实例变动的时候，服务端直接通过这个长连接将服务信息发送给客户端

客户端拿到最新服务实例数据之后的处理方式就跟1.x是一样了

除了处理方式一样，2.x也继承了1.x的其他的东西

比如客户端依然会有服务实例的缓存

定时对比机制也保留了，只不过这个定时对比的机制默认是关闭状态

之所以默认关闭，主要还是因为长连接还是比较稳定的原因

当客户端出现异常，接收不到请求，那么服务端会直接跟客户端断开连接

当恢复正常，由于有Redo操作，所以还是能拿到最新的实例信息的

所以2.x版本的服务订阅功能的实现大致如下图所示

这里还有个细节需要注意

在1.x版本的时候，任何服务都是可以被订阅的

但是在2.x版本中，只支持订阅临时服务，对于永久服务，已经不支持订阅了

小总结

服务查询1.x是通过Http请求；2.x通过gRPC请求

服务订阅1.x是通过UDP来推送的；2.x就基于gRPC长连接来实现的

1.x和2.x客户端都有服务实例的缓存，也有定时对比机制，只不过1.x会自动开启；2.x提供了一个开个，可以手动选择是否开启，默认不开启

数据一致性

由于Nacos是支持集群模式的，所以一定会涉及到分布式系统中不可避免的数据一致性问题

1、服务实例的责任机制

再说数据一致性问题之前，先来讨论一下服务实例的责任机制

什么是服务实例的责任机制？

比如上面提到的服务注册、心跳管理、监控检查机制，当只有一个Nacos服务时，那么自然而言这个服务会去检查所有的服务实例的心跳时间，执行所有服务实例的健康检查任务

但是当出现Nacos服务出现集群时，为了平衡各Nacos服务的压力，Nacos会根据一定的规则让每个Nacos服务只管理一部分服务实例的

当然每个Nacos服务的注册表还是全部的服务实例数据

这个管理机制我给他起了一个名字，就叫做责任机制，因为我在1.x和2.x都提到了responsible这个单词

本质就是Nacos服务对哪些服务实例负有心跳监测，健康检查的责任。

2、CAP定理和BASE理论

谈到数据一致性问题，一定离不开两个著名分布式理论

• CAP定理


• BASE理论

CAP定理中，三个字母分别代表这些含义：

• C，Consistency单词的缩写，代表一致性，指分布式系统中各个节点的数据保持强一致，也就是每个时刻都必须一样，不一样整个系统就不能对外提供服务


• A，Availability单词的缩写，代表可用性，指整个分布式系统保持对外可用，即使从每个节点获取的数据可能都不一样，只要能获取到就行


• P，Partition tolerance单词的缩写，代表分区容错性。

所谓的CAP定理，就是指在一个分布式系统中，CAP这三个指标，最多同时只能满足其中的两个，不可能三个都同时满足

为什么三者不能同时满足？

对于一个分布式系统，网络分区是一定需要满足的

而所谓分区指的是系统中的服务部署在不同的网络区域中

比如，同一套系统可能同时在北京和上海都有部署，那么他们就处于不同的网络分区，就可能出现无法互相访问的情况

当然，你也可以把所有的服务都放在一个网络分区，但是当网络出现故障时，整个系统都无法对外提供服务，那这还有什么意义呢？

所以分布式系统一定需要满足分区容错性，把系统部署在不同的区域网络中

此时只剩下了一致性和可用性，它们为什么不能同时满足？

其实答案很简单，就因为可能出现网络分区导致的通信失败。

比如说，现在出现了网络分区的问题，上图中的A网络区域和B网络区域无法相互访问

此时假设往上图中的A网络区域发送请求，将服务中的一个值 i 属性设置成 1

如果保证可用性，此时由于A和B网络不通，此时只有A中的服务修改成功，B无法修改成功，此时数据AB区域数据就不一致性，也就没有保证数据一致性

如果保证一致性，此时由于A和B网络不通，所以此时A也不能修改成功，必须修改失败，否则就会导致AB数据不一致

虽然A没修改成功，保证了数据一致性，AB还是之前相同的数据，但是此时整个系统已经没有写可用性了，无法成功写数据了。

所以从上面分析可以看出，在有分区容错性的前提下，可用性和一致性是无法同时保证的。

虽然无法同时一致性和可用性，但是能不能换种思路来思考一下这个问题

首先我们可以先保证系统的可用性，也就是先让系统能够写数据，将A区域服务中的i修改成1

之后当AB区域之间网络恢复之后，将A区域的i值复制给B区域，这样就能够保证AB区域间的数据最终是一致的了

这不就皆大欢喜了么

这种思路其实就是BASE理论的核心要点，优先保证可用性，数据最终达成一致性。

BASE理论主要是包括以下三点：

• 基本可用（Basically Available）：系统出现故障还是能够对外提供服务，不至于直接无法用了


• 软状态（Soft State）：允许各个节点的数据不一致


• 最终一致性，（Eventually Consistent）：虽然允许各个节点的数据不一致，但是在一定时间之后，各个节点的数据最终需要一致的

BASE理论其实就是妥协之后的产物。

3、Nacos的AP和CP

Nacos其实目前是同时支持AP和CP的

具体使用AP还是CP得取决于Nacos内部的具体功能，并不是有的文章说的可以通过一个配置自由切换。

就以服务注册举例来说，对于临时实例来说，Nacos会优先保证可用性，也就是AP

对于永久实例，Nacos会优先保证数据的一致性，也就是CP

接下来我们就来讲一讲Nacos的CP和AP的实现原理

3.1、Nacos的AP实现

对于AP来说，Nacos使用的是阿里自研的Distro协议

在这个协议中，每个服务端节点是一个平等的状态，每个服务端节点正常情况下数据是一样的，每个服务端节点都可以接收来自客户端的读写请求

当某个节点刚启动时，他会向集群中的某个节点发送请求，拉取所有的服务实例数据到自己的服务注册表中

这样其它客户端就可以从这个服务节点中获取到服务实例数据了

当某个服务端节点接收到注册临时服务实例的请求，不仅仅会将这个服务实例存到自身的服务注册表，同时也会向其它所有服务节点发送请求，将这个服务数据同步到其它所有节点

所以此时从任意一个节点都是可以获取到所有的服务实例数据的。

即使数据同步的过程发生异常，服务实例也成功注册到一个Nacos服务中，对外部而言，整个Nacos集群是可用的，也就达到了AP的效果

同时为了满足BASE理论，Nacos也有下面两种机制保证最终节点间数据最终是一致的：

• 失败重试机制


• 定时对比机制

失败重试机制是指当数据同步给其它节点失败时，会每隔3s重试一次，直到成功

定时对比机制就是指，每个Nacos服务节点会定时向所有的其它服务节点发送一些认证的请求

这个请求会告诉每个服务节点自己负责的服务实例的对应的版本号，这个版本号随着服务实例的变动就会变动

如果其它服务节点的数据的版本号跟自己的对不上，那就说明其它服务节点的数据不是最新的

此时这个Nacos服务节点就会将自己负责的服务实例数据发给不是最新数据的节点，这样就保证了每个节点的数据是一样的了。

3.2、Nacos的CP实现

Nacos的CP实现是基于Raft算法来实现的

在1.x版本早期，Nacos是自己手动实现Raft算法

在2.x版本，Nacos移除了手动实现Raft算法，转而拥抱基于蚂蚁开源的JRaft框架

在Raft算法，每个节点主要有三个状态

• Leader，负责所有的读写请求，一个集群只有一个


• Follower，从节点，主要是负责复制Leader的数据，保证数据的一致性


• Candidate，候选节点，最终会变成Leader或者Follower

集群启动时都是节点Follower，经过一段时间会转换成Candidate状态，再经过一系列复杂的选择算法，选出一个Leader

这个选举算法比较复杂，完全值得另写一篇文章，这里就不细说了。不过立个flag，如果本篇文章点赞量超过28个，我连夜爆肝，再来一篇。

当有写请求时，如果请求的节点不是Leader节点时，会将请求转给Leader节点，由Leader节点处理写请求

比如，有个客户端连到的上图中的Nacos服务2节点，之后向Nacos服务2注册服务

Nacos服务2接收到请求之后，会判断自己是不是Leader节点，发现自己不是

此时Nacos服务2就会向Leader节点发送请求，Leader节点接收到请求之后，会处理服务注册的过程

为什么说Raft是保证CP的呢？

主要是因为Raft在处理写的时候有一个判断过程

• 首先，Leader在处理写请求时，不会直接数据应用到自己的系统，而是先向所有的Follower发送请求，让他们先处理这个请求


• 当超过半数的Follower成功处理了这个写请求之后，Leader才会写数据，并返回给客户端请求处理成功


• 如果超过一定时间未收到超过半数处理成功Follower的信号，此时Leader认为这次写数据是失败的，就不会处理写请求，直接返回给客户端请求失败

所以，一旦发生故障，导致接收不到半数的Follower写成功的响应，整个集群就直接写失败，这就很符合CP的概念了。

不过这里还有一个小细节需要注意

Nacos在处理查询服务实例的请求直接时，并不会将请求转发给Leader节点处理，而是直接查当前Nacos服务实例的注册表

这其实就会引发一个问题

如果客户端查询的Follower节点没有及时处理Leader同步过来的写请求（过半响应的节点中不包括这个节点），此时在这个Follower其实是查不到最新的数据的，这就会导致数据的不一致

所以说，虽然Raft协议规定要求从Leader节点查最新的数据，但是Nacos至少在读服务实例数据时并没有遵守这个协议

当然对于其它的一些数据的读写请求有的还是遵守了这个协议。

JRaft对于读请求其实是做了很多优化的，其实从Follower节点通过一定的机制也是能够保证读到最新的数据

数据模型

在Nacos中，一个服务的确定是由三部分信息确定

• 命名空间（Namespace）：多租户隔离用的，默认是public


• 分组（Gr0up）：这个其实可以用来做环境隔离，服务注册时可以指定服务的分组，比如是测试环境或者是开发环境，默认是DEFAULT_GR0UP


• 服务名（ServiceName）：这个就不用多说了

通过上面三者就可以确定同一个服务了

在服务注册和订阅的时候，必须要指定上述三部分信息，如果不指定，Nacos就会提供默认的信息

不过，在Nacos中，在服务里面其实还是有一个集群的概念

在服务注册的时候，可以指定这个服务实例在哪个集体的集群中，默认是在DEFAULT集群下

在SpringCloud环境底下可以通过如下配置去设置

spring

  cloud:

    nacos:

      discovery:

        cluster-name: sanyoujavaCluster

在服务订阅的时候，可以指定订阅哪些集群下的服务实例

当然，也可以不指定，如果不指定话，默认就是订阅这个服务下的所有集群的服务实例

我们日常使用中可以将部署在相同区域的服务划分为同一个集群，比如杭州属于一个集群，上海属于一个集群

这样服务调用的时候，就可以优先使用同一个地区的服务了，比跨区域调用速度更快。

总结

到这，终终终于总算是讲完了Nacos作为注册中心核心的实现原理

1 ELK日志系统

经典的ELK架构或现被称为Elastic Stack。Elastic Stack架构为Elasticsearch + Logstash + Kibana + Beats的组合：

• Beats负责日志的采集


• Logstash负责做日志的聚合和处理


• ES作为日志的存储和搜索系统


• Kibana作为可视化前端展示

整体架构图：

2 EFK日志系统

容器化场景中，尤其k8s环境，用户经常使用EFK架构。F代表Fluent Bit，一个开源多平台的日志处理器和转发器。Fluent Bit可以：

• 让用户从不同来源收集数据/日志


• 统一并发到多个目的地


• 完全兼容Docker和k8s环境

3 PLG日志系统

3.1 Prometheus+k8s日志系统

PLG

Grafana Labs提供的另一个日志解决方案PLG逐渐流行。PLG架构即Promtail + Loki + Grafana的组合：

Grafana，开源的可视化和分析软件，允许用户查询、可视化、警告和探索监控指标。Grafana主要提供时间序列数据的仪表板解决方案，支持超过数十种数据源。

Grafana Loki是一组可以组成一个功能齐全的日志堆栈组件，与其它日志系统不同，Loki只建立日志标签的索引而不索引原始日志消息，而是为日志数据设置一组标签，即Loki运营成本更低，效率还提高几个数量级。

Loki设计理念

Prometheus启发，可实现可水平扩展、高可用的多租户日志系统。Loki整体架构由不同组件协同完成日志收集、索引、存储等。

各组件如下，Loki’s Architecture深入了解。Loki就是like Prometheus, but for logs。

Promtail是一个日志收集的代理，会将本地日志内容发到一个Loki实例，它通常部署到需要监视应用程序的每台机器/容器上。Promtail主要是用来发现目标、将标签附加到日志流以及将日志推送到Loki。截止到目前，Promtail可以跟踪两个来源的日志：本地日志文件和systemd日志（仅支持AMD64架构）。

4 PLG V.S ELK

4.1 ES V.S Loki

ELK/EFK架构确实强，经多年实际环境验证。存储在ES中的日志通常以非结构化JSON对象形式存储在磁盘，且ES为每个对象都建索引，以便全文搜索，然后用户可特定查询语言搜索这些日志数据。

而Loki数据存储解耦：

• 既可在磁盘存储


• 也可用如Amazon S3云存储系统

Loki日志带有一组标签名和值，只有标签对被索引，这种权衡使它比完整索引操作成本更低，但针对基于内容的查询，需通过LogQL再单独查询。

4.2 Fluentd V.S Promtail

相比Fluentd，Promtail专为Loki定制，它可为运行在同一节点的k8s Pods做服务发现，从指定文件夹读取日志。Loki类似Prometheus的标签方式。因此，当与Prometheus部署在同一环境，因为相同的服务发现机制，来自Promtail的日志通常具有与应用程序指标相同的标签，统一标签管理。

4.3 Grafana V.S Kibana

Kibana提供许多可视化工具来进行数据分析，高级功能如异常检测等机器学习功能。Grafana针对Prometheus和Loki等时间序列数据打造，可在同一仪表板上查看日志指标。

参考

• http://www.javaedge.cn/#/special

已经在一家 AI 公司入职了一个月，对坐班有些厌恶的我，没想到有一天也会开始通勤打卡。而经历了这一个月的工作，我对坐班的态度有所转变，开始理解这种工作方式对我的意义。是时候分享入职这期间的工作内容与感受。

背景

直入正题，先说职位背景。该职位的技术要求大致如下，仅做参考。

## 任职要求 

1. 本科及以上学历，计算机科学、软件工程等相关专业, 硕士优先； 

2. 扎实的 HTML、CSS、JavaScript 基础(vanilla) 功底 ； 

3. 熟练使用 React、React Native 和 Next.js 进行前端开发 

4. 了解前端性能优化技术，如代码压缩、懒加载等 

5. 熟悉前端工程化工具 

6. 具备良好的问题解决能力和团队协作精神 

7. 熟练阅读英文技术文档 

8. 有优异前端项目开发经验者优先 



## 加分项： 

- 贡献开源社区 

- 有 AI 相关项目经验。 

- 有前端性能优化和 SEO 优化经验。 

- 有良好的产品思维和设计(UI/UX)意识。 

- 有同理心思维。

- 具有一定的审美感。

很贴合国外主流的技术栈（至于为何，看后文便知），比较巧的是，我的 Web 全栈学习路线就是偏国外的技术栈。因此在技术栈上，这家公司是我喜欢的，恰巧又是 AI 开发，能让我尝试到一些前沿技术，也正好是想我折腾的。

求职经历

我是 Boss 直聘上找的（这里没给 boss 直聘打广告，我甚至还是第一次使用 boss 直聘），我有想过找人内推，但由于家庭因素被限定在福州这座城市，而内推的所在的城市往往都是那些一线城市，加上我的八股文和算法很不过关（我也很不情愿刷），到时候面试那关估计也不乐观。

因此就在 Boss 上碰碰运气，也顺带体验一下新人都是怎么找工作的。

从五一的时候开始准备简历和项目，在5号开始投简历，投递简历一关我是直接怼着工作经验1-3年的来投，而不是投应届或实习岗。因为我确实有一些工作经验，只不过不是正常的坐班打卡的形式，这在之前的博客中有说到。

在这期间共投了20多家，基本都是已读不回，就更别说投递简历了。后来我才了解到，原来 HR 回复消息是要花钱的，发布一个岗位也是。

唯一回复的还是我现在入职的这家，而且我还投了两份过去，一份是给 HR 的（没回），一份是给技术 leader 的（leader 回了）。

面试被鸽

可能是由于当时这个岗位急招的原因，在 boss 直聘上也没多说什么，leader 就约明早 11 点来公司现场初步面试聊天一下。这期间还发生了一个小变故，我到公司了，可联系不上面试官，打了微信电话也无果。待了10来分钟后我就走了，等了约一个小时都没信息，那我大概率是被鸽了，还不提前和我通知一声，然后在boss上留下了这句评价🥲。

初入职场，初次面试就这种情况，说真的我当时都有点心灰意冷了，我猜想是不是因为有其他合适的人选，于是就不招我了，就连信息也不给我打一个招呼，相当于把我拉黑似得。随后我就到附近的麦当劳花了 10 元的套餐安慰了一下自己，麦！

开始面试

直到到下午一点多的时候，面试官回复我说当时他们在开会，期间不让携带电子设备。早上就当一面过了，问我下午有没有时间，直接二面技术面(code test)过了就直接拿offer。

这时我才知道，原来早上也仅仅只是我的猜想，但我还是有点不想去了，心情有点不太愉悦，但想了想也懒得计较了，过去就当聊天罢了。到了下午面试问的就偏前端基础、八股文那些问题，其实我回答的巨烂，确实也没好好刷题，也不喜欢刷题，就面试了。自己写代码是由业务环境下驱动的，并从中寻求最佳实践。但好在我的技术面是比较广的，很多前沿的前端相关的工具库或多或少都使用过，也能侃侃而谈，加上个人 blog 和 github 这两个大加分项。就进入到了一个代码考核测试，不限框架，不限规则，使用公司的电脑打开 codesandbox 写一个todo list，前提是不使用任何 AI 工具。

这不正好到了我的强项，之前学某个框架的时候，不知道写什么demo，就写 todo list 来练手😂。恰好这次我就使用 next.js app router + Tailwindcss 的模版并且使用 form 标签的 action 和 use server 来实现新增功能。 能体现出我有在使用 next.js，而且用上了一些新特性，就拿到 offer 了。

听完之后是不是莫名的感觉这个 offer 拿的好像有点莫名其妙的感觉😂，不管怎么样结果是好的就行了。

不过拿到 offer 后，我并没有选择马上入职，经历了一次被鸽的经历，对该公司的印象带有一些怀疑。其次就是这是一家初创 AI 公司，规模不大，从应届生找工作的角度，第一份正式的工作的起点很关键，如果能直接进大厂，后续跳槽到其他公司大概率也不成问题。

但在当地我投递了 20 多家已读不回的情况下，加上这份已有的 offer 不等人（急招），加上我家里人给我推荐的工作内容我并不是很满意，于是思考了两天，最终还是选择入职了这家公司。

薪资

比较令我差异的是我与企业签订的直接劳动合同，可能是因为我直接投递 1-3 年的工作经验，但我此时的身份还是应届生，按理来说我应该是签订实习合同后，转正再签劳动合同，难道说我已经提前转正了？。不过也好，这样和学校的三方协议都可以不用签了，直接给劳动合同便可。

试用期 3 个月，薪资打 8 折。薪资在我当地还算 ok，但对于我而言并不理想。可能是会的比较多(全栈？全干！)，加上曾经赚过比这还高上许多的薪资，从内心的角度多少是有些不平衡。不过目前还是试用期，薪资这方面后续也能再谈。

接下来尤为重要的上班体验才是让我觉得没后悔入职这家公司。

上班体验

介绍一下公司部门的办公工具

办公管理：企业微信

团队协作：Slack

任务看板：Trello

代码仓库：Github

代码托管：Vercel

视频会议：Zoom

你会发现除了企业微信，其他的应用都是国外的。怎么看都不是一家国内的企业吧，这是因为我部门的 Leader 是海外留学的，这也就不难理解工具是国外应用，技术栈选型是 React 生态了。

入职的第一周部门开了个小会，就是简单介绍了一下部门的任务职责，每个成员自我介绍。重点是提供一个优质的学习环境，像是技术书籍，电子设备，UI 模版或是技术会议的门票等费用，只要对部门有利，能提升自己，都可以找他报销。

我已经找 Leader 报销了个 magic ui pro，大约 420 块，直接找财务刷卡，付款的感觉是真爽，我是真爱了🥰。

几天后，公司来了一个阿里做 B 端低代码开发的同事，也是负责前端开发，这不，我可以间接和这个老哥那学习大厂相关经验，我还正愁着没大厂相关的经验😄。

我询问他来这家公司的原因，他说被裁了，在家接外包一年了，不稳定就准备找工作，恰好这家公司急招，于是就来了。

:::warning 补

端午节后，这位老哥提离职了，原因的话我就不具体说了，可能是因为年龄大了，不适合坐班了。虽然早有预感，但还是有点不舍。因为现在部门的前端重任都在我这了😭

:::

团建

在我入职的第一周周末 Leader 为整个部门安排团建，由于这个部门成立不到 2 周，来的都是新成员，让我们自己组个局，去外面吃个饭。

也是在团建的时候了解到同事的履历一个个都不简单，有 985 的，有海外留学的，有在阿里、网易待过的，还有我这不堪回首的经历 🤡。

后面原定在 61 安排整个公司的团建，但由于天气和周末时间去的人少的因素而取消了，这我就不多说了。

端午之后的第一个工作日的中午，补过端午节部门聚餐的，这我也不多说了。就是怎么感觉这频率有点不太对，然后实际项目产出也还停留在 Spring 1 的阶段，让我有些不自在。

福利

部门每个月都会定一个最佳员工奖，我很荣幸获得部门本月的最佳员工，也感谢部门成员的认可，奖励是 300 元奖金或一日自由假。

甚至还有一张奖状，就是这奖状怎么有点像给小学生似的。（事后我才了解到这奖状还是用打印机打印的😂）

目前我已经能感受到最大的福利就是那个 magicui 动效库的模版，当然了，这个是要给公司的官网用上的，我也是蹭公司的福，给自己的站点用上了这个动效库。

此外像节日福利，如这次端午节，就是聚餐和发粽子，这也就没什么好说的。

通勤

公司距离我租房的地方只有 2 公里，每日的通勤总时间大约 40 分钟，早上大约 8 点起床，我通常坐公交车到公司附近的早餐店吃个早饭，吃完差不多 8 点 40分~50 分。中午外卖就不说了。下午下班从公交车和走路做个选择，吃完饭回到家。

黑客松

黑客松(hackathon)，也称编程马拉松比赛。我是第一次听说过这个词，Leader 给定两个选题一个是打造某市地铁智能出行，另一个是给某商场的提供贴心的购物体验，发挥自己近一个月所学的知识，去创造一个供用户使用的 AI 程序，月底交付，奖金 3000 元/小组，抽签分组。我们当时部门有个人提了一嘴，要不我们两小组自己商量一下，把奖金平分得了😂。

不过对于这个行为，我个人认为目的是为了激励员工之间协同合作，但同时也免不了技术上的内耗，毕竟这个比赛不是我们的主要工作内容。

工作内容

我想肯定有很多人对 AI 开发的刻板印象是要会大模型开发，会懂得微调，会懂得人工智能算法。这个想法也没错，但从开发 AI 应用的角度，其实蛮需要前端的，尤其是会全栈框架的前端。

这里我不得不惊叹 next.js 的生态，很多 AI 相关的例子可以直接从 Vercel 的 AI Template 下学习，预览是否有你需要的功能，Clone 到本地，然后运行项目，对某些部分进行更改。搭建 AI 应用也是异常的快。

仿 AI SDK 网站效果

Leader 下发的一个任务，入职的前两周主要让我熟悉一些怎么使用 next.js 配合 vercel 的 ai sdk 来开发 AI 应用，如怎么调用 openai 的模型，实现一个 ai chatbot。给定了一个任务就是仿造 AI SDK，由于该项目没有开源，自然就只能另辟蹊径。

首先就是仿造页面了，这个作为前端开发，实现起来也算容易，更何况这个这个页面的样式使用 Tailwindcss 编写，直接通过审查元素仿造就行了。

其次在功能实现上，ai sdk 文档都提供了非常完善的解决方案，照着文档将代码稍微改写一下便可，具体的细节就不演示了。

官网首页

两周后开始正式项目开发了，首当其冲的就是官网页。

这里当时 Leader 问我有没有用过 Gatsbyjs，要用这个框架搭建一个官网。我表明我没用过，但我提了一嘴如果要搭建偏内容向的网站，可以考虑 Astro，我愿意折腾一番（我也一直想学 Astro 的）。不过最终在开发时间和成本的商讨下还是选择使用 next.js 来搭建，leader 还顺带给我推荐了一个动效库 magicui，叫我看看里面的案例，看看能不能给官网加点动效。 之后就有了上文提到报销 magicui 的事。

Rag bot

篇幅实在有限，有关 RAG 的不做过多解释，它可以让你的 AI 应用更具有权威性，让数据的来源可靠，而非胡乱生成数据。

RAG 的基本流程就是：

在这个应用开发中，借鉴了 ragbot-starter 这个开源项目，同时向量数据库选用 datastax 公司的Astra DB。

恰好在开发这个应用的期间，我也正好在学习 Langchain.js，所以在数据处理这部分有点得心应手，目前应用还只停留在处理本地文件或用户上传的文件，只需要配置各种 File Loader 便可。

使用 RN 实现 chatbot

先看 Gif 效果。

第一次用 Screen Studio，显示的不是很好，还请见谅，主要就是实现一个流式文本效果。

这里简单说下怎么实现的，就用 react-native-reusables 的模版(React native 的 Shadcn/ui) + react-native-gen-ui 实现的，不过后者的功能比较单一，后续估计要改代码了。代码就不贴了，我怕涉嫌代码泄露（其实已经泄露差不多了）。

收获

要我说最大的收获不是遇到一个氛围不错的公司，遇到一个好 leader，也不是接触 AI 开发从中学到了什么，更不是增进了我的技术栈。而是让我养成良好的习惯，开始正常一日三餐，开始作息规律，开始将工作与生活分离，身体状态也渐渐好了起来。

下图为 5 月的生物作息，基本都保持 0 点前入睡。（不过在我写这篇文章的时候已经两点了🥱）

过去几年内我的作息与饮食都非常糟糕，能明显的感觉到状态有所下滑，编写代码的效率和能力也明显不如以前，有些力不从心。今年都快过去一半了，而我仅仅完成了2篇博文的写作，文章的输出效率明显不行😮‍💨。

如今经历了这一个月的坐班生活，可能是因为坐班而改变，也可能是公司的氛围，不管是那种，让我跳出我原有舒适区，重新拾起对新颖事物的兴趣，重新点燃学习某个技术的热情，重新找回了自我。

结尾

在我还没找工作之前，从我几个同届毕业的同学和网友的反馈得知今年的就业环境异常险峻。不仅如此，我还在网络上看到了大量工作者对自身工作的抱怨与不满，这些现象让我在工作前让我对未来的就业前景感到了一些不安。

当我亲身入局感受一番，也不禁开始低声叹气。开始思考是什么原因导致了如今大环境不好的现象，人为的制造就业焦虑，还是当下现实本就如此。当我跳出思考，回到现实难道环境好就一定挣钱多，环境差就一定挣钱少吗？社会似乎并不是这么简单的等式。

我逐渐意识到，无论大环境如何，每个人的努力和选择仍是至关重要。在面对不确定性和挑战时，保持学习和进步的态度，以及寻找自己的核心竞争力，才是应对困境的关键。

真正的职业安全感并不完全来自于外部环境，而是来自于我们自身不断提升的能力和适应变化的灵活性。

前言

大家好，我是林三心，用最通俗易懂的话讲最难的知识点是我的座右铭，基础是进阶的前提是我的初心~

ffmpeg

FFmpeg 是一个开源的、跨平台的多媒体框架，它可以用来录制、转换和流式传输音频和视频。它包括了一系列的库和工具，用于处理多媒体内容，比如 libavcodec（一个编解码库），libavformat（一个音视频容器格式库），libavutil（一个实用库），以及 ffmpeg 命令行工具本身。

FFmpeg 被广泛用于各种应用中，包括视频转换、视频编辑、视频压缩、直播流处理等。它支持多种音视频编解码器和容器格式，因此能够处理几乎所有类型的音视频文件。由于其功能强大和灵活性，FFmpeg 成为了许多视频相关软件和服务的底层技术基础。

很多网页都是用 ffmpeg 来进行视频切片，比如一个视频很大，如果通过一个连接去请求整个视频的话，那势必会导致加载时间过长，严重阻碍了用户观感

所以很多视频网站都会通过视频切片的方式来优化用户观感，就是一部分一部分地去加载出来，这样有利于用户的体验

安装 ffmpeg

安装包下载

首先到 ffmpeg 的安装网页：http://www.gyan.dev/ffmpeg/buil…

下载解压后将文件夹改名为 ffmpeg

环境变量配置

环境变量配置是为了能在电脑上使用 ffmpeg 命令行

体验 ffmpeg

先准备一个视频，比如我准备了一个视频，总共 300 多 M

视频切片

并在当前的目录下输入以下的命令

 ffmpeg -i jhys.mkv 

 -c:v libx264 

 -c:a aac 

 -hls_time 60 

 -hls_segment_type mpegts 

 -hls_list_size 0 

 -f hls 

 -max_muxing_queue_size 1024 

 output.m3u8

接着 ffmpeg 会帮你将这个视频进行分片

直到切片步骤执行完毕，我们可以看到视频已经别切成几个片了

在这个命令中：

• -i input_video.mp4 指定了输入视频文件。


• -c:v libx264 -c:a aac 指定了视频和音频的编解码器。


• -hls_time 10 指定了每个 M3U8 片段的时长，单位为秒。在这里，每个片段的时长设置为 10 秒。


• -hls_segment_type mpegts 指定了 M3U8 片段的类型为 MPEG-TS。


• -hls_list_size 0 设置 M3U8 文件中包含的最大片段数。这里设置为 0 表示没有限制。


• -f hls 指定了输出格式为 HLS。


• -max_muxing_queue_size 1024 设置了最大复用队列大小，以确保输出不会超过指定大小。


• 最后输出的文件为 output.m3u8

视频播放

创建一个简单的前端项目

可以看到浏览器会加载所有的视频切片

前言

开发过程中其实有很多小细节要去注意，只有不断去抠细节，写出精益求精的代码，从量变中收获质变。

技术的进步并非一蹴而就，而是通过无数次的量变，才能引发质的飞跃。我们始终坚信，只有对每一个细节保持敏锐的触觉，才能绽放出完美的技术之花。

从一行行代码中，我们品味到了追求卓越的滋味。每一个小小的优化，每一个微妙的改进，都是我们追求技艺的印记。我们知道，只有更多的关注细节，才能真正理解技术的本质，洞察其中的玄机。正是在对细节的把握中，我们得以成就更好的技术人生。

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

补充

20230928

针对评论区指出的第14条示例的问题，现已修正。

原来的示例贴在这里，接受大家的批评：

1. 代码风格一致性：

代码风格一致性可以提高代码的可读性和可维护性。例如，使用Java编程中普遍遵循的命名约定（驼峰命名法），使代码更易于理解。

// 不好的代码风格

int g = 10;

String S = "Hello";



// 好的代码风格

int count = 10;

String greeting = "Hello";

2. 使用合适的数据结构和集合：

选择适当的数据结构和集合类可以改进代码的性能和可读性。例如，使用HashSet来存储唯一的元素。

// 不好的例子 - 使用ArrayList存储唯一元素

List<Integer> list = new ArrayList<>();

list.add(1);

list.add(2);

list.add(1); // 重复元素



// 好的例子 - 使用HashSet存储唯一元素

Set<Integer> set = new HashSet<>();

set.add(1);

set.add(2);

set.add(1); // 自动忽略重复元素

3. 避免使用魔法数值：

使用常量或枚举来代替魔法数值可以提高代码的可维护性和易读性。

// 不好的例子 - 魔法数值硬编码

if (status == 1) {

    // 执行某些操作

}



// 好的例子 - 使用常量代替魔法数值

final int STATUS_ACTIVE = 1;

if (status == STATUS_ACTIVE) {

    // 执行某些操作

}

4. 异常处理：

正确处理异常有助于代码的健壮性和容错性，避免不必要的try-catch块可以提高代码性能。

// 不好的例子 - 捕获所有异常，没有具体处理

try {

    // 一些可能抛出异常的操作

} catch (Exception e) {

    // 空的异常处理块

}



// 好的例子 - 捕获并处理特定异常，或向上抛出

try {

    // 一些可能抛出异常的操作

} catch (FileNotFoundException e) {

    // 处理文件未找到异常

} catch (IOException e) {

    // 处理其他IO异常

}

5. 及时关闭资源：

使用完资源后，及时关闭它们可以避免资源泄漏，特别是对于文件流、数据库连接等资源。

更好的处理方式参见第16条，搭配try-with-resources食用最佳

// 不好的例子 - 未及时关闭数据库连接

Connection conn = null;

Statement stmt = null;

try {

    conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);

    stmt = conn.createStatement();

    // 执行数据库查询操作

} catch (SQLException e) {

    e.printStackTrace();

} finally {

    // 数据库连接未关闭

}



// 好的例子 - 使用try-with-resources确保资源及时关闭，避免了数据库连接资源泄漏的问题

try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);

    Statement stmt = conn.createStatement()) {

    // 执行数据库查询操作

} catch (SQLException e) {

    e.printStackTrace();

}

6. 避免过度使用全局变量：

过度使用全局变量容易引发意外的副作用和不可预测的结果，建议尽量避免使用全局变量。

// 不好的例子 - 过度使用全局变量

public class MyClass {

    private int count;



    // 省略其他代码

}



// 好的例子 - 使用局部变量或实例变量

public class MyClass {

    public void someMethod() {

        int count = 0;

        // 省略其他代码

    }

}

7. 避免不必要的对象创建：

避免在循环或频繁调用的方法中创建不必要的对象，可以使用对象池、StringBuilder等技术。

// 不好的例子 - 频繁调用方法创建不必要的对象

public String formatData(int year, int month, int day) {

    String formattedDate = String.format("%d-d-d", year, month, day); // 每次调用方法都会创建新的String对象

    return formattedDate;

}



// 好的例子 - 避免频繁调用方法创建不必要的对象

private static final String DATE_FORMAT = "%d-d-d";

public String formatData(int year, int month, int day) {

    return String.format(DATE_FORMAT, year, month, day); // 重复使用同一个String对象

}

8. 避免使用不必要的装箱和拆箱：

避免频繁地在基本类型和其对应的包装类型之间进行转换，可以提高代码的性能和效率。

// 不好的例子

Integer num = 10; // 不好的例子，自动装箱

int result = num + 5; // 不好的例子，自动拆箱



// 好的例子 - 避免装箱和拆箱

int num = 10; // 好的例子，使用基本类型

int result = num + 5; // 好的例子，避免装箱和拆箱

9. 使用foreach循环遍历集合：

使用foreach循环可以简化集合的遍历，并提高代码的可读性。

// 不好的例子 - 可读性不强，并且增加了方法调用的开销

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

for (int i = 0; i < names.size(); i++) {

    System.out.println(names.get(i)); // 不好的例子

}



// 好的例子 - 更加简洁，可读性更好，性能上也更优

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

for (String name : names) {

    System.out.println(name); // 好的例子

}

10. 使用StringBuilder或StringBuffer拼接大量字符串：

在循环中拼接大量字符串时，使用StringBuilder或StringBuffer可以避免产生大量临时对象，提高性能。

// 不好的例子 - 每次循环都产生新的字符串对象

String result = "";

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

    result += "Number " + i + ", ";

}



// 好的例子 - StringBuilder不会产生大量临时对象

StringBuilder result = new StringBuilder();

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

    result.append("Number ").append(i).append(", ");

}

11. 使用equals方法比较对象的内容：

老生常谈的问题，在比较对象的内容时，使用equals方法而不是==操作符，确保正确比较对象的内容。

// 不好的例子

String name1 = "Alice";

String name2 = new String("Alice");

if (name1 == name2) {

    // 不好的例子，使用==比较对象的引用，而非内容

}



// 好的例子

String name1 = "Alice";

String name2 = new String("Alice");

if (name1.equals(name2)) {

    // 好的例子，使用equals比较对象的内容

}

12. 避免使用多个连续的空格或制表符：

多个连续的空格或制表符会使代码看起来杂乱不堪，建议使用合适的缩进和空格，保持代码的清晰可读。

// 不好的例子

int    a = 10;  // 不好的例子，多个连续的空格和制表符

String   name   =   "John";  // 不好的例子，多个连续的空格和制表符



// 好的例子

int a = 10; // 好的例子，适当的缩进和空格

String name = "John"; // 好的例子，适当的缩进和空格

13. 使用日志框架记录日志：

在代码中使用日志框架（如Log4j、SLF4J）来记录日志，而不是直接使用System.out.println()，可以更灵活地管理日志输出和级别。

// 不好的例子：

System.out.println("Error occurred"); // 不好的例子，直接输出日志到控制台



// 好的例子：

logger.error("Error occurred"); // 好的例子，使用日志框架记录日志

14. 避免在循环中创建对象：

在循环中频繁地创建对象会导致大量的内存分配和垃圾回收，影响性能。尽量在循环外部创建对象，或使用对象池来复用对象，从而减少对象的创建和销毁开销。

// 不好的例子 - 在循环过程中频繁地创建和销毁对象，增加了垃圾回收的负担

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

    // 在每次循环迭代中创建新的对象，增加内存分配和垃圾回收的开销

    Person person = new Person("John", 30);

    System.out.println("Name: " + person.getName() + ", Age: " + person.getAge());

}





// 好的例子 - 在循环外部创建对象，减少内存分配和垃圾回收的开销

Person person = new Person("John", 30);

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

    System.out.println("Name: " + person.getName() + ", Age: " + person.getAge());



    // 可以根据需要修改 person 对象的属性

    person.setName("Alice");

    person.setAge(25);

}

15. 使用枚举替代常量：

这条其实和第3条一个道理，使用枚举可以更清晰地表示一组相关的常量，并且能够提供更多的类型安全性和功能性。

// 不好的例子 - 使用常量表示颜色

public static final int RED = 1;

public static final int GREEN = 2;

public static final int BLUE = 3;



// 好的例子 - 使用枚举表示颜色

public enum Color {

    RED, GREEN, BLUE

}

16. 使用try-with-resources语句：

在处理需要关闭的资源（如文件、数据库连接等）时，使用try-with-resources语句可以自动关闭资源，避免资源泄漏。

// 不好的例子 - 没有使用try-with-resources

FileReader reader = null;

try {

    reader = new FileReader("file.txt");

    // 执行一些操作

} catch (IOException e) {

    // 处理异常

} finally {

    if (reader != null) {

        try {

            reader.close();

        } catch (IOException e) {

            // 处理关闭异常

        }

    }

}



// 好的例子 - 使用try-with-resources自动关闭资源

try (FileReader reader = new FileReader("file.txt")) {

    // 执行一些操作

} catch (IOException e) {

    // 处理异常

}

总结

这16个小建议，希望对你有所帮助。

技术的路上充满挑战，但要相信，把细节搞好，技术会越来越牛。小小的优化，微小的改进，都能让我们的代码变得更好。

时间飞逝，我们要不断学习，不断努力。每个技术小突破都是我们不懈努力的成果。要用心倾听，用心琢磨，这样才能在技术的道路上越走越远。

从每一次写代码的过程中，我们收获更多。我们要踏实做好每个细节。在代码的世界里，细节是我们的罗盘。

坚持初心，不忘初心！

前言

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

我是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：服务器内部错误。