沉淀、分享、成长，让自己和他人都能有所收获！😄

记得那是我毕业🎓后的第一个秋天，申请了域名，搭建了论坛。可惜好景不长，没多久进入论坛后就出现各种乱七八糟的广告，而这些广告压根都不是我加的。

这是怎么回事？后来我才知道，原来我的论坛没有加 HTTPS 也就是没有 SSL 证书。那这和数学中的素数有啥关系呢？这是因为每一个 SSL 的生成都用到了 RSA 非对称加密，而 RSA 的加解密就是使用了两个互为质数的大素数生成公钥和私钥的。

这就是我们今天要分享的，关于素数在 RSA 算法中的应用。

一、什么是素数

素数（或质数）指的是大于1的且不能通过两个较小的自然数乘积得来的自然数。而大于1的自然数如果不是素数，则称之为合数。例如：7是素数，因为它的乘积只能写成 1 * 7 或者 7 * 1 这样。而像自然数 8 可以写成 2 * 4，因为它是两个较小数字的乘积。

通常在 Java 程序中，我们可以使用下面的代码判断一个数字是否为素数；

boolean isPrime = number > 0;
// 计算number的平方根为k，可以减少一半的计算量
int k = (int) Math.sqrt(number);
for (int i = 2; i <= k; i++) {
    if (number % i == 0) {
        isPrime = false;
        break;
    }
}
return isPrime;

二、对称加密和非对称加密

假如 Alice 时而需要给北漂搬砖的 Bob 发一些信息，为了安全起见两个人相互协商了一个加密的方式。比如 Alice 发送了一个银行卡密码 142857 给 Bob，Alice 会按照与 Bob 的协商方式，把 142857 * 2 = 285714 的结果传递给 Bob，之后 Bob 再通过把信息除以2拿到结果。

但一来二去，Alice 发的密码、生日、衣服尺寸、鞋子大小，都是乘以2的规律被别人发现。这下这个加密方式就不安全了。而如果每次都给不同的信息维护不同的秘钥又十分麻烦，且这样的秘钥为了安全也得线下沟通，人力成本又非常高。

所以有没有另外一种方式，使用不同的秘钥对信息的加密和解密。当 Bob 想从 Alice 那获取信息，那么 Bob 就给 Alice 一个公钥，让她使用公钥对信息进行加密，而加密后的信息只有 Bob 手里有私钥才能解开。那么这样的信息传递就变得非常安全了。如图所示。

对称加密	非对称加密

三、算法公式推导

如果 Alice 希望更安全的给 Bob 发送的信息，那么就需要保证经过公钥加密的信息不那么容易被反推出来。所以这里的信息加密，会需用到求模运算。像计算机中的散列算法，伪随机数都是求模运算的典型应用。

例如；5^3 mod 7 = 6 —— 5的3次幂模7余6

• 5相当于 Alice 要传递给 Bob 的信息

• 3相当于是秘钥

• 6相当于是加密后的信息

经过求模计算的结果6，很难被推到出秘钥信息，只能一个个去验证；

5^1 mod 7 = 5
5^2 mod 7 = 3
5^3 mod 7 = 6
5^4 mod 7 = 2
...

但如果求模的值特别大，例如这样：5^3 mod 78913949018093809389018903794894898493... = 6 那么再想一个个计算就有不靠谱了。所以这也是为什么会使用模运算进行加密，因为对于大数来说对模运算求逆根本没法搞。

根据求模的计算方式，我们得到加密和解密公式；—— 关于加密和解密的公式推到，后文中会给出数学计算公式。

对于两个公式我们做一下更简单的转换；

从转换后的公式可以得知，m 的 ed 次幂，除以 N 求求模可以得到 m 本身。那么 ed 就成了计算公钥加密的重要因素。为此这里需要提到数学中一个非常重要的定理，欧拉定理。—— 1763年，欧拉发现。

欧拉定理：m^φ(n) ≡ 1 (mod n) 对于任何一个与 n 互质的正整数 m，的 φ(n) 次幂并除以 n 去模，结果永远等于1。φ(n) 代表着在小于等于 n 的正整数中，有多少个与 n 互质的数。

例如：φ(8) 小于等于8的正整数中 1、2、3、4、5、6、7、8 有 1、3、5、7 与数字 8 互为质数。所以 φ(8) = 4 但如果是 n 是质数，那么 φ(n) = n - 1 比如 φ(7) 与7互为质数有1、2、3、4、5、6 所有 φ(7) = 6

接下来我们对欧拉公式做一些简单的变换，用于看出ed的作用；

经过推导的结果可以看到 ed = kφ(n) + 1，这样只要算出加密秘钥 e 就可以得到一个对应的解密秘钥 d。那么整套这套计算过程，就是 RSA 算法。

四、关于RSA算法

RSA加密算法是一种非对称加密算法，在公开秘钥加密和电子商业中被广泛使用。

于1977年，三位数学家；罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字命名，叫做RSA算法。

1973年，在英国政府通讯总部工作的数学家克利福德·柯克斯（Clifford Cocks）在一个内部文件中提出了一个与之等效的算法，但该算法被列入机密，直到1997年才得到公开。

RSA 的算法核心在于取了2个素数做乘积求和、欧拉计算等一系列方式算得公钥和私钥，但想通过公钥和加密信息，反推出来私钥就会非常复杂，因为这是相当于对极大整数的因数分解。所以秘钥越长做因数分解越困难，这也就决定了 RSA 算法的可靠性。—— PS：可能以上这段话还不是很好理解，程序员👨🏻‍💻还是要看代码才能悟。接下来我们就来编写一下 RSA 加密代码。

五、实现RSA算法

RSA 的秘钥生成首先需要两个质数p、q，之后根据这两个质数算出公钥和私钥，在根据公钥来对要传递的信息进行加密。接下来我们就要代码实现一下 RSA 算法，读者也可以根据代码的调试去反向理解 RSA 的算法过程，一般这样的学习方式更有抓手的感觉。嘿嘿 抓手

1. 互为质数的p、q

两个互为质数p、q是选择出来的，越大越安全。因为大整数的质因数分解是非常困难的，直到2020年为止，世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长，用RSA加密的信息实际上是不能被破解的。—— 不知道量子计算机出来以后会不会改变。如果改变，那么程序员又有的忙了。

2. 乘积n

n = p * q 的乘积。

public long n(long p, long q) {
    return p * q;
}

3. 欧拉公式 φ(n)

φ(n) = (p - 1) * (q - 1)

public long euler(long p, long q) {
    return (p - 1) * (q - 1);
}

4. 选取公钥e

e 的值范围在 1 < e < φ(n)

public long e(long euler){
    long e = euler / 10;
    while (gcd(e, euler) != 1){
        e ++;
    }
    return e;
}

5. 选取私钥d

d = (kφ(n) + 1) / e

public long inverse(long e, long euler) {
    return (euler + 1) / e;
}

6. 加密

c = m^e mod n

public long encrypt(long m, long e, long n) {
    BigInteger bM = new BigInteger(String.valueOf(m));
    BigInteger bE = new BigInteger(String.valueOf(e));
    BigInteger bN = new BigInteger(String.valueOf(n));
    return Long.parseLong(bM.modPow(bE, bN).toString());
}

7. 解密

m = c^d mod n

public long decrypt(long c, long d, long n) {
    BigInteger bC = new BigInteger(String.valueOf(c));
    BigInteger bD = new BigInteger(String.valueOf(d));
    BigInteger bN = new BigInteger(String.valueOf(n));
    return Long.parseLong(bC.modPow(bD, bN).toString());
}

8. 测试

@Test
public void test_rsa() {
    RSA rsa = new RSA();
    long p = 3,                         // 选取2个互为质数的p、q
            q = 11,                     // 选取2个互为质数的p、q
            n = rsa.n(p, q),            // n = p * q
            euler = rsa.euler(p, q),    // euler = (p-1)*(q-1)
            e = rsa.e(euler),           // 互为素数的小整数e | 1 < e < euler
            d = rsa.inverse(e, euler),  // ed = φ(n) + 1 | d = (φ(n) + 1)/e
            msg = 5;                    // 传递消息 5
            
    System.out.println("消息：" + msg);
    System.out.println("公钥(n,e)：" + "(" + n + "," + e + ")");
    System.out.println("私钥(n,d)：" + "(" + n + "," + d + ")");
    
    long encrypt = rsa.encrypt(msg, e, n);
    System.out.println("加密（消息）：" + encrypt);
    
    long decrypt = rsa.decrypt(encrypt, d, n);
    System.out.println("解密（消息）：" + decrypt);
}

测试结果

消息：5
公钥(n,e)：(33,3)
私钥(n,d)：(33,7)
加密（消息）：26
解密（消息）：5

• 通过选取3、11作为两个互质数，计算出公钥和私钥，分别进行消息的加密和解密。如测试结果消息5的加密后的信息是26，解密后获得原始信息5

六、RSA数学原理

整个 RSA 的加解密是有一套数学基础可以推导验证的，这里小傅哥把学习整理的资料分享给读者，如果感兴趣可以尝试验证。这里的数学公式会涉及到；求模运算、最大公约数、贝祖定理、线性同于方程、中国余数定理、费马小定理。当然还有一些很基础的数论概念；素数、互质数等。以下推理数学内容来自博客：luyuhuang.tech/2019/10/24/…

1. 模运算

1.1 整数除法

定理 1 令 a 为整数, d 为正整数, 则存在唯一的整数 q 和 r, 满足 0⩽r<d, 使得 a=dq+r.

当 r=0 时, 我们称 d 整除 a, 记作 d∣a; 否则称 d 不整除 a, 记作 d∤a

整除有以下基本性质:

定理 2 令 a, b, c 为整数, 其中 a≠0a≠0. 则:

• 对任意整数 m,n，如果 a∣b 且 a∣c, 则 a∣(mb + nc)

• 如果 a∣b, 则对于所有整数 c 都有 a∣bc

• 如果 a∣b 且 b∣c, 则 a∣c

1.2 模算术

在数论中我们特别关心一个整数被一个正整数除时的余数. 我们用 a mod m = b表示整数 a 除以正整数 m 的余数是 b. 为了表示两个整数被一个正整数除时的余数相同, 人们又提出了同余式(congruence).

定义 1 如果 a 和 b 是整数而 m 是正整数, 则当 m 整除 a - b 时称 a 模 m 同余 b. 记作 a ≡ b(mod m)

a ≡ b(mod m) 和 a mod m= b 很相似. 事实上, 如果 a mod m = b, 则 a≡b(mod m). 但他们本质上是两个不同的概念. a mod m = b 表达的是一个函数, 而 a≡b(mod m) 表达的是两个整数之间的关系.

模算术有下列性质:

定理 3 如果 m 是正整数, a, b 是整数, 则有

(a+b)mod m=((a mod m)+(b mod m)) mod m

ab mod m=(a mod m)(b mod m) mod m

根据定理3, 可得以下推论

推论 1 设 m 是正整数, a, b, c 是整数; 如果 a ≡ b(mod m), 则 ac ≡ bc(mod m)

证明 ∵ a ≡ b(mod m), ∴ (a−b) mod m=0 . 那么

(ac−bc) mod m=c(a−b) mod m=(c mod m⋅(a−b) mod m) mod m=0

∴ ac ≡ bc(mod m)

需要注意的是, 推论1反之不成立. 来看推论2:

推论 2 设 m 是正整数, a, b 是整数, c 是不能被 m 整除的整数; 如果 ac ≡ bc(mod m) , 则 a ≡ b(mod m)

证明 ∵ ac ≡ bc(mod m) , 所以有

(ac−bc)mod m=c(a−b)mod m=(c mod m⋅(a−b)mod m) mod m=0

∵ c mod m≠0 ,

∴ (a−b) mod m=0,

∴a ≡ b(mod m) .

2. 最大公约数

如果一个整数 d 能够整除另一个整数 a, 则称 d 是 a 的一个约数(divisor); 如果 d 既能整除 a 又能整除 b, 则称 d 是 a 和 b 的一个公约数(common divisor). 能整除两个整数的最大整数称为这两个整数的最大公约数(greatest common divisor).

定义 2 令 a 和 b 是不全为零的两个整数, 能使 d∣ad∣a 和 d∣bd∣b 的最大整数 d 称为 a 和 b 的最大公约数. 记作 gcd(a,b)

2.1 求最大公约数

如何求两个已知整数的最大公约数呢? 这里我们讨论一个高效的求最大公约数的算法, 称为辗转相除法. 因为这个算法是欧几里得发明的, 所以也称为欧几里得算法. 辗转相除法基于以下定理:

引理 1 令 a=bq+r, 其中 a, b, q 和 r 均为整数. 则有 gcd(a,b)=gcd(b,r)

证明 我们假设 d 是 a 和 b 的公约数, 即 d∣a且 d∣b, 那么根据定理2, d 也能整除 a−bq=r 所以 a 和 b 的任何公约数也是 b 和 r 的公约数;

类似地, 假设 d 是 b 和 r 的公约数, 即 d∣bd∣b 且 d∣rd∣r, 那么根据定理2, d 也能整除 a=bq+r. 所以 b 和 r 的任何公约数也是 a 和 b 的公约数;

因此, a 与 b 和 b 与 r 拥有相同的公约数. 所以 gcd(a,b)=gcd(b,r).

辗转相除法就是利用引理1, 把大数转换成小数. 例如, 求 gcd(287,91) 我们就把用较大的数除以较小的数. 首先用 287 除以 91, 得

287=91⋅3+14

我们有 gcd(287,91)=gcd(91,14) . 问题转换成求 gcd(91,14). 同样地, 用 91 除以 14, 得

91=14⋅6+7

有 gcd(91,14)=gcd(14,7) . 继续用 14 除以 7, 得

14=7⋅2+0

因为 7 整除 14, 所以 gcd(14,7)=7. 所以 gcd(287,91)=gcd(91,14)=gcd(14,7)=7.

我们可以很快写出辗转相除法的代码:

def gcd(a, b):
    if b == 0: return a
    return gcd(b, a % b)

2.2 贝祖定理

现在我们讨论最大公约数的一个重要性质:

定理 4 贝祖定理 如果整数 a, b 不全为零, 则 gcd(a,b)是 a 和 b 的线性组合集 {ax+by∣x,y∈Z}中最小的元素. 这里的 x 和 y 被称为贝祖系数

证明 令 A={ax+by∣x,y∈Z}. 设存在 x0x0, y0y0 使 d0d0 是 A 中的最小正元素, d0=ax0+by0 现在用 d0去除 a, 这就得到唯一的整数 q(商) 和 r(余数) 满足

又 0⩽r<d0, d0 是 A 中最小正元素

∴ r=0 , d0∣a.

同理, 用 d0d0 去除 b, 可得 d0∣b. 所以说 d0 是 a 和 b 的公约数.

设 a 和 b 的最大公约数是 d, 那么 d∣(ax0+by0)即 d∣d0

∴∴ d0 是 a 和 b 的最大公约数.

我们可以对辗转相除法稍作修改, 让它在计算出最大公约数的同时计算出贝祖系数.

def gcd(a, b):
    if b == 0: return a, 1, 0
    d, x, y = gcd(b, a % b)
    return d, y, x - (a / b) * y

3. 线性同余方程

现在我们来讨论求解形如 ax≡b(modm) 的线性同余方程. 求解这样的线性同余方程是数论研究及其应用中的一项基本任务. 如何求解这样的方程呢? 我们要介绍的一个方法是通过求使得方程 ¯aa≡1(mod m) 成立的整数 ¯a. 我们称 ¯a 为 a 模 m 的逆. 下面的定理指出, 当 a 和 m 互素时, a 模 m 的逆必然存在.

定理 5 如果 a 和 m 为互素的整数且 m>1, 则 a 模 m 的逆存在, 并且是唯一的.

证明 由贝祖定理可知, ∵ gcd(a,m)=1 , ∴ 存在整数 x 和 y 使得 ax+my=1 这蕴含着 ax+my≡1(modm) ∵ my≡0(modm), 所以有 ax≡1(modm)

∴ x 为 a 模 m 的逆.

这样我们就可以调用辗转相除法 gcd(a, m) 求得 a 模 m 的逆.

a 模 m 的逆也被称为 a 在模m乘法群 Z∗m 中的逆元. 这里我并不想引入群论, 有兴趣的同学可参阅算法导论

求得了 a 模 m 的逆 ¯a 现在我们可以来解线性同余方程了. 具体的做法是这样的: 对于方程 ax≡b(modm)a , 我们在方程两边同时乘上 ¯a, 得 ¯aax≡¯ab(modm)

把 ¯aa≡1(modm) 带入上式, 得 x≡¯ab(modm)

x≡¯ab(modm) 就是方程的解. 注意同余方程会有无数个整数解, 所以我们用同余式来表示同余方程的解.

4. 中国余数定理

中国南北朝时期数学著作 孙子算经 中提出了这样一个问题:

有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二。问物几何？

用现代的数学语言表述就是: 下列同余方程组的解释多少?

孙子算经 中首次提到了同余方程组问题及其具体解法. 因此中国剩余定理称为孙子定理.

定理 6 中国余数定理 令 m1,m2,…,mn 为大于 1 且两两互素的正整数, a1,a2,…,an 是任意整数. 则同余方程组

有唯一的模 m=m1m2…mnm=m1m2…mn 的解.

证明 我们使用构造证明法, 构造出这个方程组的解. 首先对于 i=1,2,…,ni=1,2,…,n, 令

即, MiMi 是除了 mimi 之外所有模数的积. ∵∵ m1,m2,…,mn 两两互素, ∴∴ gcd(mi,Mi)=1. 由定理 5 可知, 存在整数 yiyi 是 MiMi 模 mimi 的逆. 即

上式等号两边同时乘 aiai 得

就是第 i 个方程的一个解; 那么怎么构造出方程组的解呢? 我们注意到, 根据 Mi 的定义可得, 对所有的 j≠ij≠i, 都有 aiMiyi≡0(modmj). 因此我们令

就是方程组的解.

有了这个结论, 我们可以解答 孙子算经 中的问题了: 对方程组的每个方程, 求出 MiMi , 然后调用 gcd(M_i, m_i) 求出 yiyi:

最后求出 x=−2⋅35+3⋅21+2⋅15=23≡23(mod105)

5. 费马小定理

现在我们来看数论中另外一个重要的定理, 费马小定理(Fermat's little theorem)

定理 7 费马小定理 如果 a 是一个整数, p 是一个素数, 那么

当 n 不为 p 或 0 时, 由于分子有质数p, 但分母不含p; 故分子的p能保留, 不被约分而除去. 即 p∣(np).

令 b 为任意整数, 根据二项式定理, 我们有

令 a=b+1, 即得 a^p ≡ a(mod p)

当 p 不整除 a 时, 根据推论 2, 有 a^p−1 ≡ 1(mod p)

6. 算法证明

我们终于可以来看 RSA 算法了. 先来看 RSA 算法是怎么运作的:

RSA 算法按照以下过程创建公钥和私钥:

1. 随机选取两个大素数 p 和 q, p≠qp≠q;

2. 计算 n=pq

3. 选取一个与 (p−1)(q−1) 互素的小整数 e;

4. 求 e 模 (p−1)(q−1) 的逆, 记作 d;

5. 将 P=(e,n)公开, 是为公钥;

6. 将 S=(d,n)保密, 是为私钥.

所以 RSA 加密算法是有效的.

(1) 式表明, 不仅可以用公钥加密, 私钥解密, 还可以用私钥加密, 公钥解密. 即加密计算 C=M^d mod n, 解密计算 M=C^e mod n

RSA 算法的安全性基于大整数的质因数分解的困难性. 由于目前没有能在多项式时间内对整数作质因数分解的算法, 因此无法在可行的时间内把 n 分解成 p 和 q 的乘积. 因此就无法求得 e 模 (p−1)(q−1)的逆, 也就无法根据公钥计算出私钥.

七、常见面试题

• 质数的用途

• RSA 算法描述

• RSA 算法加解密的过程

• RSA 算法使用场景

• 你了解多少关于 RSA 的数学数论知识

• RSA加密算法：zh.wikipedia.org/wiki/RSA%E5…

• RSA算法原理： http://www.ruanyifeng.com/blog/2013/0…

• RSA算法背后的数学原理：luyuhuang.tech/2019/10/24/…

• 莱昂哈德·欧拉：en.wikipedia.org/wiki/Leonha…

源码：github.com/fuzhengwei/…
作者：小傅哥
来源：juejin.cn/post/7173830290812370958

与产品MM那些事

新来一个产品MM，因为比较平，我们就叫她A妹吧。A妹来第一天就指出：页面顶部的Banner广告位的背景是白色的，太单调啦，人家不喜欢啦，需要根据广告图片的内容自动切换背景颜色，颜色要与广告图主色调一致。作为一名合格的码农我直接回绝了，我说咱们的应用主打简洁，整这花里胡哨的干嘛，劳民伤财。A妹也没放弃，与我深入交流了一夜成功说服了我。

其实要实现这个需求也不难，Google已经为我们提供了一个方便的工具————Palette。

前言

Palette即调色板这个功能其实很早就发布了，Jetpack同样将这个功能也纳入其中，想要使用这个功能，需要先依赖库

implementation 'androidx.palette:palette:1.0.0'

本篇文章就来讲解一下如何使用Palette在图片中提取颜色。

创建Palette

创建Palette其实很简单，如下

var builder = Palette.from(bitmap)
var palette = builder.generate()

这样，我们就通过一个Bitmap创建一个Pallete对象。

注意：直接使用Palette.generate(bitmap)也可以，但是这个方法已经不推荐使用了，网上很多老文章中依然使用这种方式。建议还是使用Palette.Builder这种方式。

generate()这个函数是同步的，当然考虑图片处理可能比较耗时，Android同时提供了异步函数

public AsyncTask<Bitmap, Void, Palette> generate(
       @NonNull final PaletteAsyncListener listener) {

通过一个PaletteAsyncListener来获取Palette实例，这个接口如下：

public interface PaletteAsyncListener {
   /**
    * Called when the {@link Palette} has been generated. {@code null} will be passed when an
    * error occurred during generation.
    */
   void onGenerated(@Nullable Palette palette);
}

提取颜色

有了Palette实例，就可以通过Palette对象的相应函数就可以获取图片中的颜色，而且不只一种颜色，下面一一列举：

• getDominantColor：获取图片中的主色调

• getMutedColor：获取图片中柔和的颜色

• getDarkMutedColor：获取图片中柔和的暗色

• getLightMutedColor：获取图片中柔和的亮色

• getVibrantColor：获取图片中有活力的颜色

• getDarkVibrantColor：获取图片中有活力的暗色

• getLightVibrantColor：获取图片中有活力的亮色

这些函数都需要提供一个默认颜色，如果这个颜色Swatch无效则使用这个默认颜色。光这么说不直观，我们来测试一下，代码如下：

var bitmap = BitmapFactory.decodeResource(resources, R.mipmap.a)
var builder = Palette.from(bitmap)
var palette = builder.generate()
color0.setBackgroundColor(palette.getDominantColor(Color.WHITE))
color1.setBackgroundColor(palette.getMutedColor(Color.WHITE))
color2.setBackgroundColor(palette.getDarkMutedColor(Color.WHITE))
color3.setBackgroundColor(palette.getLightMutedColor(Color.WHITE))
color4.setBackgroundColor(palette.getVibrantColor(Color.WHITE))
color5.setBackgroundColor(palette.getDarkVibrantColor(Color.WHITE))
color6.setBackgroundColor(palette.getLightVibrantColor(Color.WHITE))

运行后结果如下：

这样各个颜色的差别就一目了然。除了上面的函数，还可以使用getColorForTarget这个函数，如下：

@ColorInt
public int getColorForTarget(@NonNull final Target target, @ColorInt final int defaultColor) {

这个函数需要一个Target，提供了6个静态字段，如下：

/**
* A target which has the characteristics of a vibrant color which is light in luminance.
*/
public static final Target LIGHT_VIBRANT;

/**
* A target which has the characteristics of a vibrant color which is neither light or dark.
*/
public static final Target VIBRANT;

/**
* A target which has the characteristics of a vibrant color which is dark in luminance.
*/
public static final Target DARK_VIBRANT;

/**
* A target which has the characteristics of a muted color which is light in luminance.
*/
public static final Target LIGHT_MUTED;

/**
* A target which has the characteristics of a muted color which is neither light or dark.
*/
public static final Target MUTED;

/**
* A target which has the characteristics of a muted color which is dark in luminance.
*/
public static final Target DARK_MUTED;

其实就是对应着上面除了主色调之外的六种颜色。

文字颜色自动适配

在上面的运行结果中可以看到，每个颜色上面的文字都很清楚的显示，而且它们并不是同一种颜色。其实这也是Palette提供的功能。

通过下面的函数，我们可以得到各种色调所对应的Swatch对象：

• getDominantSwatch

• getMutedSwatch

• getDarkMutedSwatch

• getLightMutedSwatch

• getVibrantSwatch

• getDarkVibrantSwatch

• getLightVibrantSwatch

注意：同上面一样，也可以通过getSwatchForTarget(@NonNull final Target target)来获取

Swatch类提供了以下函数：

• getPopulation(): 样本中的像素数量

• getRgb(): 颜色的RBG值

• getHsl(): 颜色的HSL值

• getBodyTextColor(): 能都适配这个Swatch的主体文字的颜色值

• getTitleTextColor(): 能都适配这个Swatch的标题文字的颜色值

所以我们通过getBodyTextColor()和getTitleTextColor()可以很容易得到在这个颜色上可以很好现实的标题和主体文本颜色。所以上面的测试代码完整如下：

var bitmap = BitmapFactory.decodeResource(resources, R.mipmap.a)
var builder = Palette.from(bitmap)
var palette = builder.generate()

color0.setBackgroundColor(palette.getDominantColor(Color.WHITE))
color0.setTextColor(palette.dominantSwatch?.bodyTextColor ?: Color.WHITE)

color1.setBackgroundColor(palette.getMutedColor(Color.WHITE))
color1.setTextColor(palette.mutedSwatch?.bodyTextColor ?: Color.WHITE)

color2.setBackgroundColor(palette.getDarkMutedColor(Color.WHITE))
color2.setTextColor(palette.darkMutedSwatch?.bodyTextColor ?: Color.WHITE)

color3.setBackgroundColor(palette.getLightMutedColor(Color.WHITE))
color3.setTextColor(palette.lightMutedSwatch?.bodyTextColor ?: Color.WHITE)

color4.setBackgroundColor(palette.getVibrantColor(Color.WHITE))
color4.setTextColor(palette.vibrantSwatch?.bodyTextColor ?: Color.WHITE)

color5.setBackgroundColor(palette.getDarkVibrantColor(Color.WHITE))
color5.setTextColor(palette.darkVibrantSwatch?.bodyTextColor ?: Color.WHITE)

color6.setBackgroundColor(palette.getLightVibrantColor(Color.WHITE))
color6.setTextColor(palette.lightVibrantSwatch?.bodyTextColor ?: Color.WHITE)

这样每个颜色上的文字都可以清晰的显示。

那么这个标题和主体文本颜色有什么差别，他们又是如何的到的？我们来看看源码：

/**
* Returns an appropriate color to use for any 'title' text which is displayed over this
* {@link Swatch}'s color. This color is guaranteed to have sufficient contrast.
*/
@ColorInt
public int getTitleTextColor() {
   ensureTextColorsGenerated();
   return mTitleTextColor;
}

/**
* Returns an appropriate color to use for any 'body' text which is displayed over this
* {@link Swatch}'s color. This color is guaranteed to have sufficient contrast.
*/
@ColorInt
public int getBodyTextColor() {
   ensureTextColorsGenerated();
   return mBodyTextColor;
}

可以看到都会先执行ensureTextColorsGenerated()，它的源码如下：

private void ensureTextColorsGenerated() {
   if (!mGeneratedTextColors) {
       // First check white, as most colors will be dark
       final int lightBodyAlpha = ColorUtils.calculateMinimumAlpha(
               Color.WHITE, mRgb, MIN_CONTRAST_BODY_TEXT);
       final int lightTitleAlpha = ColorUtils.calculateMinimumAlpha(
               Color.WHITE, mRgb, MIN_CONTRAST_TITLE_TEXT);

       if (lightBodyAlpha != -1 && lightTitleAlpha != -1) {
           // If we found valid light values, use them and return
           mBodyTextColor = ColorUtils.setAlphaComponent(Color.WHITE, lightBodyAlpha);
           mTitleTextColor = ColorUtils.setAlphaComponent(Color.WHITE, lightTitleAlpha);
           mGeneratedTextColors = true;
           return;
      }

       final int darkBodyAlpha = ColorUtils.calculateMinimumAlpha(
               Color.BLACK, mRgb, MIN_CONTRAST_BODY_TEXT);
       final int darkTitleAlpha = ColorUtils.calculateMinimumAlpha(
               Color.BLACK, mRgb, MIN_CONTRAST_TITLE_TEXT);

       if (darkBodyAlpha != -1 && darkTitleAlpha != -1) {
           // If we found valid dark values, use them and return
           mBodyTextColor = ColorUtils.setAlphaComponent(Color.BLACK, darkBodyAlpha);
           mTitleTextColor = ColorUtils.setAlphaComponent(Color.BLACK, darkTitleAlpha);
           mGeneratedTextColors = true;
           return;
      }

       // If we reach here then we can not find title and body values which use the same
       // lightness, we need to use mismatched values
       mBodyTextColor = lightBodyAlpha != -1
               ? ColorUtils.setAlphaComponent(Color.WHITE, lightBodyAlpha)
              : ColorUtils.setAlphaComponent(Color.BLACK, darkBodyAlpha);
       mTitleTextColor = lightTitleAlpha != -1
               ? ColorUtils.setAlphaComponent(Color.WHITE, lightTitleAlpha)
              : ColorUtils.setAlphaComponent(Color.BLACK, darkTitleAlpha);
       mGeneratedTextColors = true;
  }
}

通过代码可以看到，这两种文本颜色实际上要么是白色要么是黑色，只是透明度Alpha不同。

这里面有一个关键函数，即ColorUtils.calculateMinimumAlpha()：

public static int calculateMinimumAlpha(@ColorInt int foreground, @ColorInt int background,
       float minContrastRatio) {
   if (Color.alpha(background) != 255) {
       throw new IllegalArgumentException("background can not be translucent: #"
               + Integer.toHexString(background));
  }

   // First lets check that a fully opaque foreground has sufficient contrast
   int testForeground = setAlphaComponent(foreground, 255);
   double testRatio = calculateContrast(testForeground, background);
   if (testRatio < minContrastRatio) {
       // Fully opaque foreground does not have sufficient contrast, return error
       return -1;
  }

   // Binary search to find a value with the minimum value which provides sufficient contrast
   int numIterations = 0;
   int minAlpha = 0;
   int maxAlpha = 255;

   while (numIterations <= MIN_ALPHA_SEARCH_MAX_ITERATIONS &&
          (maxAlpha - minAlpha) > MIN_ALPHA_SEARCH_PRECISION) {
       final int testAlpha = (minAlpha + maxAlpha) / 2;

       testForeground = setAlphaComponent(foreground, testAlpha);
       testRatio = calculateContrast(testForeground, background);

       if (testRatio < minContrastRatio) {
           minAlpha = testAlpha;
      } else {
           maxAlpha = testAlpha;
      }

       numIterations++;
  }

   // Conservatively return the max of the range of possible alphas, which is known to pass.
   return maxAlpha;
}

它根据背景色和前景色计算前景色最合适的Alpha。这期间如果小于minContrastRatio则返回-1，说明这个前景色不合适。而标题和主体文本的差别就是这个minContrastRatio不同而已。

回到ensureTextColorsGenerated代码可以看到，先根据当前色调，计算出白色前景色的Alpha，如果两个Alpha都不是-1，就返回对应颜色；否则计算黑色前景色的Alpha，如果都不是-1，返回对应颜色；否则标题和主体文本一个用白色一个用黑色，返回对应颜色即可。

更多功能

上面我们创建Palette时先通过Palette.from(bitmap)的到了一个Palette.Builder对象，通过这个builder可以实现更多功能，比如：

• addFilter：增加一个过滤器

• setRegion：设置图片上的提取区域

• maximumColorCount：调色板的最大颜色数 等等

总结

通过上面我们看到，Palette的功能很强大，但是它使用起来非常简单，可以让我们很方便的提取图片中的颜色，并且适配合适的文字颜色。同时注意因为ColorUtils是public的，所以当我们需要文字自动适配颜色的情况时，也可以通过ColorUtils的几个函数自己实现计算动态颜色的方案。

作者：BennuCTech
来源：juejin.cn/post/7077380907333582879

前言

之前偶然间看到某APP点赞有个炸裂的效果，觉得有点意思，就尝试了下，轻微还原，效果图如下

封装粒子

从动画效果中我们可以看到，当动画开始的时候，会有一组粒子从四面八方散射出去，然后逐渐消失，于是可以定义一个粒子类包含以下属性

public class Particle {
    public float x, y;
    public float startXV;
    public float startYV;
    public float angle;
    public float alpha;
    public Bitmap bitmap;
    public int width, height;
}

• x，y是粒子的位置信息

• startXV，startYV是X方向和Y方向的速度

• angle是发散出去的角度

• alpha是粒子的透明度

• bitmap, width, height即粒子图片信息 我们在构造函数中初始化这些信息，给定一些默认值

public Particle(Bitmap originalBitmap) {
    alpha = 1;
    float scale = (float) Math.random() * 0.3f + 0.7f;
    width = (int) (originalBitmap.getWidth() * scale);
    height = (int) (originalBitmap.getHeight() * scale);
    bitmap = Bitmap.createScaledBitmap(originalBitmap, width, height, true);

    startXV = new Random().nextInt(150) * (new Random().nextBoolean() ? 1 : -1);
    startYV = new Random().nextInt(170) * (new Random().nextBoolean() ? 1 : -1);
    int i = new Random().nextInt(360);
    angle = (float) (i * Math.PI / 180);

    float rotate = (float) Math.random() * 180 - 90;
    Matrix matrix = new Matrix();
    matrix.setRotate(rotate);
    bitmap = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, false);
    originalBitmap.recycle();
}

仔细看效果动画，会发现同一个图片每次出来的旋转角度会有不同，于是，在创建bitmap的时候我们随机旋转下图片。

绘制粒子

有了粒子之后，我们需要将其绘制在View上，定义一个ParticleView，重写onDraw()方法，完成绘制

public class ParticleView extends View {
    Paint paint;
    List<Particle> particles = new ArrayList<>();
    //.....省略构造函数
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        for (Particle particle : particles) {
            paint.setAlpha((int) (particle.alpha * 255));
            canvas.drawBitmap(particle.bitmap, particle.x - particle.width / 2, particle.y - particle.height / 2, paint);
        }
    }
    public void setParticles(List<Particle> particles) {
        this.particles = particles;
    }
}

管理粒子

绘制的时候我们发现需要不断改变粒子的x,y值，才能使它动起来，所以我们需要一个ValueAnimator，然后通过监听动画执行情况，不断绘制粒子。

private void startAnimator(View emiter) {
    ValueAnimator valueAnimator = ObjectAnimator.ofInt(0, 1).setDuration(1000);
    valueAnimator.addUpdateListener(animation -> {
        for (Particle particle : particles) {
            particle.alpha = 1 - animation.getAnimatedFraction();
            float time = animation.getAnimatedFraction();
            time *= 10;
            particle.x = startX - (float) (particle.startXV * time * Math.cos(particle.angle));
            particle.y = startY - (float) (particle.startYV * time * Math.sin(particle.angle) - 9.8 * time * time / 2);
        }
        particleView.invalidate();
    });
    valueAnimator.start();
}

由于我们的点赞按钮经常出现在RecyclerView的item里面，而点赞动画又是全屏的，所以不可能写在item的xml文件里面，而且我们需要做到0侵入，在不改变原来的逻辑下添加动画效果。

我们可以通过activity.findViewById(android.R.id.content)获取FrameLayout然后向他添加子View

public ParticleManager(Activity activity, int[] drawableIds) {
    particles = new ArrayList<>();
    for (int drawableId : drawableIds) {
        particles.add(new Particle(BitmapFactory.decodeResource(activity.getResources(), drawableId)));
    }
    topView = activity.findViewById(android.R.id.content);
    topView.getLocationInWindow(parentLocation);
}

首先我们通过构造函数传入当前Activity以及我们需要的图片资源，然后将图片资源都解析成Particle对象，保存在particles中，然后获取topView以及他的位置信息。

然后需要知道动画从什么位置开始，传入一个view作为锚点

public void start(View emiter) {
    int[] location = new int[2];
    emiter.getLocationInWindow(location);
    startX = location[0] + emiter.getWidth() / 2 - parentLocation[0];
    startY = location[1] - parentLocation[1];
    particleView = new ParticleView(topView.getContext());
    topView.addView(particleView);
    particleView.setParticles(particles);
    startAnimator(emiter);
}

通过传入一个emiter，计算出起始位置信息并初始化particleView中的粒子信息，最后开启动画。

使用

val ids = ArrayList<Int>()
for (index in 1..18) {
    val id = resources.getIdentifier("img_like_$index", "mipmap", packageName);
    ids.add(id)
}
collectImage.setOnClickListener {
    ParticleManager(this, ids.toIntArray())
        .start(collectImage)
}

运行之后会发现基本和效果图一致，但是其实有个潜在的问题，我们只是向topView添加了view，并没有移除，虽然界面上看不到，其实只是因为我们的粒子在最后透明度都是0了，将粒子透明度最小值设置为0.1后运行会发现，动画结束之后粒子没有消失，会越堆积越多，所以我们还需要移除view。

valueAnimator.addListener(new AnimatorListenerAdapter() {
    @Override
    public void onAnimationStart(Animator animation, boolean isReverse) {
    }
    @Override
    public void onAnimationEnd(Animator animation) {
        topView.removeView(particleView);
        topView.postInvalidate();
    }
    @Override
    public void onAnimationCancel(Animator animation) {
        topView.removeView(particleView);
        topView.postInvalidate();
    }
});

移除的时机放在动画执行完成，所以继续使用之前的valueAnimator，监听他的完成事件，移除view，当然，如果动画取消了也需要移除。

作者：晚来天欲雪_
来源：juejin.cn/post/7086471790502871054

前言

近期公司组织了一次代码评鉴，在这边记录下学习到的一些规范吧

案例

案例1

• 参数过多，改为对象好一些

const start = (filename, version, isFirst, branch, biz) => {
    // ....
}

案例2

• query不应该直接透传

• 对象解构可能导致覆盖，可以调下顺序

// ...
await axios.post('xxx', {
    data: {
        host: 'xxx'
        ...getQuery()
    }
})

案例3

• 超过三个条件的判断抽出为表达式或者函数

• 魔法数字用变量代替

• 与和非不一起使用

if (bottom < boxMaxH && topRemain < boxMax || top > 20) {
}

作者：沐晓
来源：juejin.cn/post/7173595497641443364

我创业了

• 3年前立的flag，现在做到了我当时难以想象的程度，我自己一直激励我自己，要努力，要坚持！结果如何，交给老天！

• 我离职了，结束了4年的前端职业生涯，比我想象的要快很多！休息了几天，来聊一聊这几年的经历，希望能够给到大家帮助（挺后悔的，因为在这个时间点离职，就意味着没有年终了，虽然已经说服了自己，但是，刚离职完，同事就和我说公司裁员了，血亏！！！！！！害想想就来气，我的N+1，4个月呢，十几万就这样飞了！好了不说了闲话了，难受！）

• 月哥这一路走来充满鸡血，经常写鸡汤文章，激励大家，其实也在激励我自己在努力的奋斗，没办法，学历低，履历差，我哪有时间抱怨，我只能拼搏，奋斗，因为我知道我只有这样我才可能有一些，别人看不上的机会，但是需要我这种人拼尽全力，才能获取到的！

月哥这十年

• 2012年上大学，因为穷，借了助学贷款，也在学校拿贫困生补助，安徽工程大学机电学院（三本计算机系）

• 2014年参军-2016年退伍 中国人民解放军 陆军 某特殊兵种（其实当兵的主要原因就是穷，那时候当兵可以免学费，而且还有补助，我家里农村的，两个人上大学，欠了很多钱,学费也是东拼西凑，没办法！）

• 2017年实习，学的java,实习岗位c#,在合肥，工资1900，干了29天被开。永远的痛啊

• IT干不下去了，要生活，17年转行至游泳教练，龙格亲子游泳，干了一年，锻炼了自己很强的耐心，因为学员是0-6岁的宝宝！教他们游泳，玩水！

• 18年5月底，说服自己重新干回前端，感觉自己在学习上从来没有做出过什么，高考也好，去部队也好，关于学习，一切都是不用心，除了学习其他都挺好，身体不错，但是始终在浑浑噩噩在逃避学习，不敢直面自己的内心，感觉天天泡水不是我自己想要的生活，同学们也在一个一个的找到不错的工作，甚至有的人还去了中大厂，又想到泡在水里的自己，心里很不是滋味，有一种叫做"挫败感"的东西，正在如影随形地跟着我;我决定再拼最后一把，失败与否，干一把；遂报名某马培训前端，

• 18年6月底毕业！6年大学生涯，此时我24岁！属于大龄了！

• 18年8月初，第一次找工作，学完jq,找到15k，因为没学框架，心里虚，拒绝了没去，然后自学node,vue

• 18年9月中旬，出来面试，背完两本面试宝典！一天当场拿到两个offer，一个16k,一个17k,然后直接入职了；依稀的记得，那天下午面完试，我下了公司的楼，然后去小店买了包软中，蹲在路边抽，百感交集！10月底拿到19koffer，心虚没敢去！以前行情好，简历上不写项目都可以拿到offer，只要会吹，然后拿到了有生以来第一个学习上的第一名，某马上海前端25期，第一个找到工作的，也是工资最高的，5月中旬到9月18号找到工作，历时4个月！

• 入职3月就做了前端leader,优势能喝酒，能吹牛，能做事，敢承担，又是军人出身！领导比较喜欢！

• 19年涨薪3千至2w

• 19年10月出去面试，拿到某安 36w-42w offer，去了要降月base，年终8-12月，觉得不靠谱，没去！同时背调因为第一家公司的问题，背调出了问题，吃一堑长一智！

• 20年7月跳槽至目前这家公司，工资23K * 14 ; 试用期6个月结束：表现突出，涨薪4k，年中又涨薪2k ,21年中旬，base到29k , 职级p6+,又带了小团队！

• 21年出去面试，拿到（29+1）* 17 的offer，医疗行业，没去，还有其他一堆的offer！

• 22年出去面试，拿到 44*16 offer，链圈技术专家岗位，没去！

• 22年11月，离职创业！结束4年前端职业生涯，开始新的职业！

关于学习

大家都知道我比较的努力,喜欢写励志文章，因为我相信，当数量累计到一定程度的时候，就会发生质的变化，这句话也在我身上深刻的体现出来。学不会我就硬学，我智商不够体力来凑，结果？？？？，不坚持做怎么知道结果是好是坏，于是乎我秉承大力出奇迹的思路，疯狂学习

• 在培训班的时候，我先预习课程，因为可以在网上买到录屏课，然后代码先敲三遍，然后第二天上课的时候等于就在复习，我的学习节奏保持领先学校的课程一周，就这样还是效果不好，我抓狂啊，我怀疑我自己，表面上每天都在继续，每天似乎都在一样的过去，但某些在内心深处涌动的东西却在不断的积累，直到后来我才知道，那是斗志，来自狼血深处的斗志，终于在一天爆发了。我在电脑上冲动地敲上了给自己看的一行字，“要么赢得风风光光，要么输得精精光光”，狂怒的表达了那种必死的心理，近乎于歇斯底里的疯。

• 然后学完js就是疯狂刷面试题，刚开始确实不会，也看不太懂，但是我猖狂啊，我尼玛，都这样，还能输啥，干 ！我就背下来，两本面试宝典扎扎实实的背了下来，然后到天台，让同学随便出题，我来答，就这样循环往复，我背下来了，并且掌握了面试的答题套路，同时我也理解了很多知识点。

• 学到js其实也是一知半解，然后开始抄笔记，疯狂抄，笔记本抄完**，发现复盘的时候翻页太麻烦，还是不好记，然后想到抄到a4纸上面，这样每一页的内容就是非常多了，然后 贴墙上，天天背，后面自然就通了**！

• 然后就有了后来的故事，学完jq出去面试就拿到了15k,然后自学完了vue,node，拿到了16k,17k,19k,20k,29k,30多k,44k ，时间记录成长，虽然不跳槽，但是我没事喜欢出去面试，看看自己还值多少钱！

• 时间记录了成长，努力见证了成果！入职之后也是抓一切能够学习的机会，地铁上，摸鱼时间，早起... 反正就是学，狂学！

• 大家看我的学习经历就知道，我不是一个智商很高的人，刚开始学什么都很慢，就是硬怼数量，硬坚持，虽然不知道能够带了什么样的结果，但是每次收获的结果都是令自己什么吃惊的！

焦虑，迷茫

• 高强度的学习，肯定是充满疲惫，焦虑，同时没有取得成果之前，你自己也会很迷茫，我也是！

• 我不知道我这么努力，我能不能取得一些成果，但是，我确信一点就是，我如果不努力，我肯定毛机会都没有。所以我强压自己，先做，坚持持续的做，每当焦虑的时候，我就会去抄书、抄代码、看书，这些真的很有效果，阅读可以让我安静下来，抄书也能够让我安静下来，忙起来就没有时间乱想了，前期是非常痛苦的，但是后面就是很舒服了。

• 我专门弄了一个文件，然后就是在焦虑的时候狂抄代码，类似promise啊，各种手写，少则无脑写了10多遍，多则几十遍，那必然是都背下来了，那必然是理解了其中的逻辑！经过时间的积累，大家可以猜一猜这个文件的代码行数有多少了，有没有过20w行代码？所以焦虑一直伴随着我，直到现在，但是我不怕，焦虑了我就去学习，不管目标，就是干！

关于生活

• 因为以前都很穷，物质欲望没有那么高，我刚来上海的时候，那时候工资3000多，刚开始住在宿舍，但是我觉得比较贵，每个月得快1000块钱，因为每个月还得存1000多，所以觉得成本太高了，当你穷的时候，1块钱都能难倒英雄汉呀！

• 于是我搬家到了虹桥的华漕的民房，因为便宜，但是生活条件差了比较多，没有厕所，几平米的房间，连桌子都放不下，还得600多块，上厕所得跑到村里的公厕，冬天还能忍一忍，但是夏天不行，实在没法洗澡，身上臭的很，于是又换了旁边的二楼

• 然后就是热，贼热，因为二楼就是顶楼，楼板房子，住过的应该都知道，当然肯定没有空调的，连电风扇都没有！对！我为了省钱，我连电风扇都没有买，就是这个刚！但是好处是门口有水龙头，实在太热，我就出来，冲凉，然后再回去睡

• 终于买了电风扇，为什么呢，因为我的同学来上海找工作，然后住在我这里，当天晚上他就受不了了，他问我你怎么能住的下去的，然后我花了几十块钱，买了电风扇，于是我有的电风扇，然后他在这住了两周，就回了老家，说在上海实在是太艰苦了。先走了！

• 上班的话，就骑不知道多少手的n手自行车，然后有时候骑车到淞虹路，有时候骑到二号航站楼，反正都是几公里。小黄车我肯定是不舍得骑的，毕竟基本每天都骑，挺贵的！

• 累习惯，反正也能受得了，吃的饱就好，因为当过兵，在部队的时候经历的可能比这个艰苦多了，所以我觉得还挺好，挺幸福了！

• 然后就是转行到了前端，17年来的上海，18年底才终于住了有空调的房子，然后就是一室户，然后就是一室一厅，然后就是三室一厅

• 到现在，正在买房子，准备在上海定居了！

关于工作

• 我是很卷的，很努力，领导都喜欢我这种人，听话，干活快，产出高，能加班，问题少，还能喝酒！

• 我在这家公司，公司的领导，hr都知道我干副业，但是也没说啥，因为我干活还是很好的，产出高，bug少，第一家公司优秀员工，目前这家公司连续获得季度优秀员工！

• 这样做的好处就是，每次我找领导加工资，都很有话语权，第一家公司，我要求加5000，然后加了3000，第二家，转正我就要加工资，加了4000，然后年中又加了2000；我就秉承着我干的好，你就必须给我加钱，不然我没有动力干，半年不加工资，我就感觉没有工作动力了，那我就得跑路（因为我有随时跳槽的能力）。因为表现确实不错，所以每次加薪都很顺利！

• 我入职一家公司，我就开始准备跳槽了，因为我相信机会是留给有准备的人的，下面是我真实的简历，现在也用不到了，分享给大家看看！

• 我在公司的人际关系我觉得还是很不错的，包括和后端，产品测试同学，我其实9月份就提离职了，我们领导说，你不如忍一忍，拿完年终再走，毕竟也不少钱，然后hr也是这样说，你不再考虑考虑拿完年终再走！但是现在实在太忙，我也实话实说，留下来也会影响到工作，虽然我不用怎么干活，熬到年后也是可以的，但是人过留名，我不想背骂名，哈哈！然后就愉快的离职了！

• 要明确自己打工人的身份，我就要多挣钱，你只要给我画饼，我就要立马吃，顺着你的路走，你不得不给我钱。我们在公司就要自己的利益最大化，干好事是前提，不然你没有话语权！我只卷学习，技术越来越好，所以我干活效率高，干活快，每天又大量的时间摸鱼，那我就疯狂的学习，学源码！领导喜欢看，那我就做你喜欢的事，这样我找你加工资的时候，你就没话说的吧！职场小技巧，哈哈！

关于副业--->主业

• 为什么离职，因为副业做的太大了，今年暴涨，学员也突破了千人，团队的规模也越来越大，开公司，整合团队，希望把这件事做的越来越好，目前团队有13个人，4名p8+级别大佬，3位p7大佬，有5名伙伴全职all in到这块，主要分为两块，培训（0基础，面试辅导，进阶辅导，晋升辅导，管理辅导），和接外包私活！

• 这一年多以来，基本上很少的休息时间，因为周六日要给学员面试辅导，而且还要写文章，自己还得不断的学习，经常就是3-4点睡觉，然后7-8点起床去上班，有的时候每天只睡2个多小时，有时候凌晨我还在群里发消息，没办法，你做了这件事，就得把这件事做好！贼累，因为要同时兼顾好副业，和工作！

• 我老婆之前问我，你不累吗？我说怎么可能不累，但是还能坚持！

• 然后11月魔鬼训练营放开了报名，一下子报名了50多位同学，直接给我顶离职了，原来你用心做培训，是真的会被别人认可的！市场不会说谎！

争议，谩骂

• 做培训，经常被骂，被diss,说你割韭菜，就包括写文章，文末引流，被骂的太多了，但是了解下来的就会知道，我们不是卖课的，我们是做服务的，1对1辅导，你直接来吃我们这群里整理好的面试，项目经验，来1对1的给你把关，给你指导，你的提高能不快吗！

• 而且看这个报名的人数就知道，我们效果差的话，怎么可能这么多人来报名，而且大家都是在职的，有的年入百万也来报名学习，很多大厂的同学也来报名辅导，因为这个不是吹出来的，真正的让他们看到了来到这边能够获取到价值的

• 我的学员拿遍了全国所有大厂的offer，薪资比我高的有好多个，有的还是我的两倍，这是我最骄傲的事情，最远的学员，在美国，新加坡，目前也进了美国的top大厂，很开心，做培训最开心的事情莫过于学员能够超过自己，我们也是毫无保留的给他们辅导！

• 骂我也好，说我割韭菜也罢，我现在也不太关注这些声音，我只要能给学员带来真正的提升就好。你不参与，你根本不知道我做的好不好，教的垃圾不垃圾！

关于身体

• 很多人觉得我吃不消，虽然我很久没锻炼了，但是老本厚，来来来，上图！

• 所以，加班熬夜我顶的住，然后现在离职了，也就开始有时间锻炼了！此处需要66个赞，哈哈！关于我怎么练的，我这么扣的人怎么可能去健身房，从小就壮，干农活，十多岁就能开拖拉机下地了，穷人的孩子早当家！

• 大家一定要注意身体！别硬干！身体是革命的本钱，我也是日常去医院检查身体，切记，身体第一！

关于收入

• 说一个笑话吧！以下纯属虚构--> 收入暴涨的心态，当第一个月收入过10万的时候，兴奋啊，激动啊，后面每个月，都越来越多之后，心态也就没那么激动了，很平常了！

• 士兵突击里面的装甲团的团长说过一句话，一直激励着我，“想要，和得到之间还需要做到！”

关于未来

• 我很早就清晰的明白，拼技术，很难拼的过各位大佬，你们随便学一学都比我强很多，这是必须要承认的；就像我们培训出来的一些校招拿到sp的同学，一毕业就30k,我这种学历怎么比，没法比呀！虽然说这四年看来在工作技术上还可以，但是对比顶层还有巨大的差距，这些差距不是努力能够追上的，因为别人也在努力，只有反其道而行，利用自己的优势，把自己的优势无限的扩大，才能够有机会。我技术上干不过你，那我就把你招进来，做我的合作伙伴！这种方式能够最快弥补自己短板，然后就没有短板了！以前不敢想，现在团队招来了这么多p7,p8的大佬，我在正确的道路上坚持的做着，就是为了能够给到学员带来巨大的价值，学各位大佬的精华，补充到自己身上！我们能够做的就是，想尽一切办法快速的提升实力，找这些大佬solo，无疑是最快的方式！

• 我自身有很强的毅力和决心，以及很好的自律性，这些年的经历告诉我，韧性非常重要，坚持住，就算失败了，也无所谓，过程最精彩，结果就是成盒 ，so what!

• 嗯嗯嗯，不知道能做到什么程度，但是不变的是，要努力，要坚持，要做学员的榜样，既然选择了创业，all in 在前后端培训上面，就要好好服务学员，给他们带来价值，让他们觉得花的钱太值了，那我就扛起枪，持续的战斗下去！结果交给老天，管它个锤子！

寄语

• 抱怨没有用，焦虑是日常，当你抱怨时，当你焦虑中，其实你是对现状的不满，你内心肯定要往好的方面走，你还有变好的欲望，我们需要这些欲望，来当作我们的动力源泉，持续坚持下去！反向去利用，你会得到正向反馈！

• 当你一点焦虑都没有的时候，你也不会抱怨的时候，那么恭喜你看透了

• 很多人说努力没有用，我想问你真正努力过吗？这个你得和你自己对话，你才能够更加的清晰，不要假努力，结果不会说谎；你基础很好，算法很好，源码很好，项目也很有思考，你会拿到很差的offer吗？ 我想大概率不会，你不一定能够进大厂，履历、学历、运气也有很大的关系，但是有的不错的涨薪还是能够做到的，和别人比太累，只和自己的昨天比。我进步了，我就很开心！大家加油，不卷，也不能躺平，别等到被裁，然后不好找工作才知道，再去后悔，那时候你会发现努力学习真的有用

• 千万、一定，不要放弃努力！或许段时间内看不到结束，但厚积薄发才是最佳方式背水一战，逼到绝境反而可能练出真本事！因为没的选！

• 好了，这是我的4年，大家看一看我是拼的学历、智商、履历还是拼的努力、坚持、韧性！我是月哥，我为自己代言！下一个四年拭目以待！

• 感谢大家的观看和点赞、转发；也可添加月哥微信lisawhy0706沟通交流，结尾依旧是：长风破浪会有时，直挂云帆济沧海

作者：前端要努力
来源：juejin.cn/post/7170596452266147871

朋友居家办公期间，他们老板为了远程监控工作，要求大家必须装上专门的软件和摄像头。

我还记得，Ta花了一个晚上来安装这些东西……

但万万没想到，为了关怀员工监督工作，老板们的奇招简直一山更比一山高：

连读取脑电波都想出来了。

就算你居家办公，老板甚至还能观测到你的心情。

而要实现这个神操作，只需要一个耳机就够了。

不同于普通耳机，这种耳机上还有几个专门读取人脑电波的电极。

戴上它后，既不用动手也不用说话，AI就能快速读心，帮你操控电脑。

好家伙，老板们竟然如此紧跟潮流，都把当下正红火的脑机接口搬进办公室了。

这种“读心耳机”的背后的开发者宣称：“戴上它，不仅能提高工作效率，还可以让员工更快乐。”

据IEEE Spectrum报道，关于这项新技术，有2家公司最为突出：

一个是来自以色列的InnerEye，另一个是硅谷神经技术公司Emotiv，不少老板都投资了他们。

那么，他们的耳机到底靠谱吗？

读取员工脑电波，AI快速做决策

先来看看InnerEye的头戴式耳机，它共有7个通道来读取人的脑电图。

他们的技术人员开发了一个专门的InnerEye软件，来接收、分析大脑信号，并和商业脑电扫描系统搭配使用。

AI可以整合人眼球活动信号、脑电波，以及电脑屏幕信息，快速做出决策。

举个栗子~

机场的安检员需要盯着X光扫描图流，判断行李中是否有违禁物品。

戴上InnerEye的耳机后，安检员每秒能处理3到10张图像，比纯用肉眼+手动记录快了一个量级。

至于原因嘛，一是安检员不用再敲键盘了，直接“意念控制”计算机就行；二是在人还没全完想清楚时，AI可能已经找出了违禁物品。

“这个系统的判断结果，和人类手动操作时一样准确”，InnerEye的研发副总裁Vaisman如是说道。

另外，当佩戴者闭眼或者注意力不集中时，AI还可以检测出来，并且再次显示错过的图像。

有意思的是，人类带着这个耳机处理任务时，AI还在继续根据人的大脑活动不断深度学习。

不过在这个过程中，人类虽然不一定要主动决策，但还得是懂行的（比如这里是职业安检员），并且要保持专注。

而比起InnerEye，Emotiv的耳机更加小巧。

它的外观看起来很像蓝牙运动耳机，甚至连贴头皮的电极都无影无踪了。

不过玄机正藏在左右两个耳塞里，这里面有电极，用来读取脑电波。

Emotiv公司研发了一个叫MN8的系统，也和商业脑电扫描系统搭配使用。

通过这些系统，佩戴者可以看到他们个人的注意力集中程度以及压力水平。

实际上，脑电图技术早在1912年就被科学家发明出来了，随后很快在医学领域被普及。

但过去扫描脑电图时，需要用一种叫导电膏的东西来固定电极，并保证生物信号能够稳定准确地传输。

而且为了提升空间分辨率，电极或“通道”往往越多越好，有时一个脑电帽甚至有200多个电极。

△脑电帽示意图

而现在，已经有了不需导电膏的“干式”电极，再加上AI也发展迅猛，于是出现了众多轻便的新式脑机接口设备，包括头戴式耳机。

既然操作简化、成本大幅下降，不难猜到，下一个动作应该就是商用普及了。

神经伦理专家表示担忧

虽然这种耳机的开发者很看好它的前景，甚至还说员工戴上之后可以更快乐。

但不少神经学伦理专家和学者却表示，并没看出哪里让人快乐了，而是感到害怕好吗…

比如，埃默里大学神经学和精神病学系的副教授Karen Rommelfanger说：

我认为老板对使用这种技术有很大的兴趣，但不知道雇员是否也有兴趣。

绝大多数研究脑机接口的公司，并没有为技术商用做好充分准备。

乔治敦大学的Mark Giordano教授也觉得，员工基本会对此产生抵触情绪，因为这涉嫌侵犯了他们的隐私和人权。

Giordano教授认为，这种技术对某些特定职业确实有些帮助，比如运输、建筑行业，可以用此检测工人的疲劳程度，保障他们的安全。

但对于办公室的白领而言，似乎没有明显的好处。

即便公司的初衷是提高员工福利，但可能很快就变味儿了。

如果员工的生产效率普遍提高，公司难免会跟着提高绩效标准，员工的压力反而变大了。（懂的都懂…）

但无论如何，专家们预测，就现在的发展趋势，这种读取脑电波的设备可能会很快普及。

所以，它们的诸多安全隐患，必须尽早解决。

背后的技术公司

话说回来，“读心耳机”背后的这两家公司，到底是什么来头？

其中，Emotiv成立于2011年，目前已经发布了三种型号的轻型脑电波扫描设备。

之前他们的产品主要是卖给神经科学研究人员；部分也会卖给一些开发者，这些人主要研究的是基于大脑控制的程序或游戏。

从今年起，Emotiv开始盯上了企业，他们发布了第四代MN8系统，并搞出了能读取脑电波的耳机。

Emotiv的CEO兼创始人Tan Le大胆猜测，五年后这种大脑追踪设备会变得随处可见。

至于安全隐患，Le表示Emotiv已经意识到了这些趋势，他们会严格审查合作公司，来保护员工隐私：

只有员工自己才能看到个人的注意力和压力水平，领导们只能看到团队的匿名数据汇总。

Innereye则成立于2013年，他们的官网上赫然写着公司愿景：

把人类的智慧与人工智能结合起来。

那么，戴上能读脑电波的耳机，是否可以算把人类智慧和AI的能力结合起来？

如果未来老板让你戴上能读取脑电波的东西，你会接受吗？

参考链接：
[1]https://www.iflscience.com/employers-are-investing-in-tech-that-constantly-reads-employee-brainwaves-to-optimize-performance-66426
[2]https://spectrum.ieee.org/neurotech-workplace-innereye-emotiv

来源：Alex 发自 凹非寺

2022年接近尾声，鸽了近一年，是时候补一下去年的年终总结了。

2021年对我来说是一个意义重大的一年。

这一年，我们团队开发出了一款基于canvas的类word文档编辑器，并因此产品获得了公司最高荣誉——产品创新奖。

当时感慨良多，早该总结一下的，终因自己的懒惰，拖到了现在。

直到这周五晚上，在我想着罗织什么借口推迟，以便于周末能放飞自我的时候，老天终于看不下去了，我被电话告知了核酸同管阳性……

产品介绍

懒惰是可耻的，发自内心的忏悔过后，我还是要稍稍骄傲的介绍下编辑器产品：

整个编辑器都是用canvas底层API绘制的，包括了它的光标，滚动条。

除了弹窗及右键菜单的UI组件外，所有的核心功能都是手搓TS，没有用任何的插件。

包括：核心，排版，光标管理，分页，文本编辑，图片，表格，列表，表单控件，撤销还原，页面设置，页眉页脚等的所有功能，都只源于canvas提供的这几个底层的API接口：

• 在直角坐标系下，从一点到另一点画一个矩形，或圆，或三角。

• 测绘字体宽高。

• 从某一点绘制一个指定样式的字。

接口简单，但是经过层层封装，配合健壮的架构和性能良好的算法，就实现了各种复杂的功能。

看一下几个特色功能：

1. 丰富的排版形式：

1. 复杂的表格拆分：

1. 灵活的列表：

1. 表单控件：

1. 独有的字符对齐：

1. 辅助输入

1. 痕迹对比：

此外，我们开发了c++打印插件，可以灵活的定制各种打印功能。

基础的排版也不演示了，“，。》”等标点不能在行首，一些标点不能在行尾，文字基线等排版基础省略一百八十二个字，

性能也非常不错，三百页数据秒级加载。

提供全个功能的程序接口，借助模版功能，完成各种复杂的操作功能。

心路历程

开发

这么复杂的项目我们开发了多长时间呢？

答案是一年。事实是前年底立项，去年初开始开发，团队基本只有我一人（其实项目初期还有另一个老技术人员，技术也很强，很遗憾开始合作不到两周老技术员就离开这个项目了），一直到7月份团队进了4个强有力的新成员，又经过了半年的紧锣密鼓的开发，不出意外的就意外开发完了。

真实怀念那段忙碌的日子，仿佛一坐下一抬头就要吃午饭了，一坐一抬头又晚上了，晚上还要继续在小区里一圈圈散步考虑各种难点的实现技术方案。真是既充实又酣畅淋漓。

由衷的感谢每一位团队成员的辛苦付出，尽管除了我这个半混半就得老开发，其他还都是1年到4年开发经验的伪新兵蛋子，但是每个人都表现出了惊人的开发效率和潜力。

这让我深刻理解到，任何一个牛掰的项目，都是需要团队齐心协力完成的。现在这个战斗力超强的团队，也是我值得骄傲的底气。

上线，惨遭毒打

事实证明，打江山难，守江山更难，项目开发亦是如此，尤其是在项目刚刚面向用户使用阶段。

当我们还沉浸在获得成功的喜悦中时，因为糟糕的打印速度及打印清晰度问题被用户一顿骑脸输出，打印相关体验之前从未在我们的优化计划之内。而这是用户难以忍受的。

好在持续半个月驻现场加班加点，终于得到了一定的优化。后面我们也是自研c++打印插件，打印问题算是得到彻底解决。

之后仍然有大大小小的问题层出不穷，还好渐渐趋于稳定。

当然现在还是有一些小问题，这是属于这个产品成长的必经之路。

现在，该产品在成千上万用户手中得以稳定运行，偶尔博得称赞，既感到骄傲，又感觉所有辛苦与委屈不值一提。

未来

之前跟领导沟通过开源的问题，领导也有意向开源，佩服领导的远大格局及非凡气度。但现在还不太成熟，仍需从长计议。

随着编辑器功能的完善，一些难以解决的问题也浮出水面，例如对少数民族语言的支持。开源是一个好的方式，可以让大家一同来完善它。

感慨

1. 勇气，是你最走向成功的首要前提。当我主动申请要做这个项目时，身边大部分人给我的忠告是不要做。不尝试一下，怎么知道能不能做好呢。不给自己设限，大胆尝试。

2. 满足来源于专注。

3. 小团队作战更有效率。

4. 产品与技术不分家，既要精进技术，也要有产品思维。技术是产品的工具，产品是技术的目的。如何做出用户体验良好的产品，是高级研发的高级技能。

感悟很多，一时不知道说啥了，有时间单独再细聊聊。

碎碎念

不知道是幸运还是不幸，公司秃然安排研发在线版excel了，无缝衔接了属于是，身为高质量打工人，抖M属性值点满，没有困难创造困难也要上。

同时今年也发生了一件十分悲痛的事，好朋友的身体垮了。身体是革命的本钱。最后就总结三个重点：健康，健康，还是TMD健康。

作者：张三风
来源：juejin.cn/post/7172975010724708389

mybatis-plus作为mybatis的增强工具，它的出现极大的简化了开发中的数据库操作，但是长久以来，它的联表查询能力一直被大家所诟病。一旦遇到left join或right join的左右连接，你还是得老老实实的打开xml文件，手写上一大段的sql语句。

直到前几天，偶然碰到了这么一款叫做mybatis-plus-join的工具（后面就简称mpj了），使用了一下，不得不说真香！彻底将我从xml地狱中解放了出来，终于可以以类似mybatis-plus中QueryWrapper的方式来进行联表查询了，话不多说，我们下面开始体验。

引入依赖

首先在项目中引入引入依赖坐标，因为mpj中依赖较高版本mybatis-plus中的一些api，所以项目建议直接使用高版本。

<dependency>
    <groupId>com.github.yulichang</groupId>
    <artifactId>mybatis-plus-join</artifactId>
    <version>1.2.4</version>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.1</version>
</dependency>

引入相关依赖后，在springboot项目中，像往常一样正常配置数据源连接信息就可以了。

数据准备

因为要实现联表查询，所以我们先来建几张表进行测试。

订单表：

用户表，包含用户姓名：

商品表，包含商品名称和单价：

在订单表中，通过用户id和商品id与其他两张表进行关联。

修改Mapper

以往在使用myatis-plus的时候，我们的Mapper层接口都是直接继承的BaseMapper，使用mpj后需要对其进行修改，改为继承MPJBaseMapper接口。

@Mapper
public interface OrderMapper extends MPJBaseMapper<Order> {
}

对其余两个表的Mapper接口也进行相同的改造。此外，我们的service也可以选择继承MPJBaseService，serviceImpl选择继承MPJBaseServiceImpl，这两者为非必须继承。

查询

Mapper接口改造完成后，我们把它注入到Service中，虽然说我们要完成3张表的联表查询，但是以Order作为主表的话，那么只注入这一个对应的OrderMapper就可以，非常简单。

@Service
@AllArgsConstructor
public class OrderServiceImpl implements OrderService {
    private final OrderMapper orderMapper;
}

MPJLambdaWrapper

接下来，我们体验一下再也不用写sql的联表查询：

public void getOrder() {
    List<OrderDto> list = orderMapper.selectJoinList(OrderDto.class,
     new MPJLambdaWrapper<Order>()
      .selectAll(Order.class)
      .select(Product::getUnitPrice)
      .selectAs(User::getName,OrderDto::getUserName)
      .selectAs(Product::getName,OrderDto::getProductName)
      .leftJoin(User.class, User::getId, Order::getUserId)
      .leftJoin(Product.class, Product::getId, Order::getProductId)
      .eq(Order::getStatus,3));

    list.forEach(System.out::println);
}

不看代码，我们先调用接口来看一下执行结果：

可以看到，成功查询出了关联表中的信息，下面我们一点点介绍上面代码的语义。

首先，调用mapper的selectJoinList()方法，进行关联查询，返回多条结果。后面的第一个参数OrderDto.class代表接收返回查询结果的类，作用和我们之前在xml中写的resultType类似。

这个类可以直接继承实体，再添加上需要在关联查询中返回的列即可：

@Data
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class OrderDto extends Order {
    String userName;
    String productName;
    Double unitPrice;
}

接下来的MPJLambdaWrapper就是构建查询条件的核心了，看一下我们在上面用到的几个方法：

• selectAll()：查询指定实体类的全部字段

• select()：查询指定的字段，支持可变长参数同时查询多个字段，但是在同一个select中只能查询相同表的字段，所以如果查询多张表的字段需要分开写

• selectAs()：字段别名查询，用于数据库字段与接收结果的dto中属性名称不一致时转换

• leftJoin()：左连接，其中第一个参数是参与联表的表对应的实体类，第二个参数是这张表联表的ON字段，第三个参数是参与联表的ON的另一个实体类属性

除此之外，还可以正常调用mybatis-plus中的各种原生方法，文档中还提到，默认主表别名是t，其他的表别名以先后调用的顺序使用t1、t2、t3以此类推。

我们用插件读取日志转化为可读的sql语句，可以看到两条左连接条件都被正确地添加到了sql中：

MPJQueryWrapper

和mybatis-plus非常类似，除了LamdaWrapper外还提供了普通QueryWrapper的写法，改造上面的代码：

public void getOrderSimple() {
    List<OrderDto> list = orderMapper.selectJoinList(OrderDto.class,
     new MPJQueryWrapper<Order>()
      .selectAll(Order.class)
      .select("t2.unit_price","t2.name as product_name")
      .select("t1.name as user_name")
      .leftJoin("t_user t1 on t1.id = t.user_id")
      .leftJoin("t_product t2 on t2.id = t.product_id")
      .eq("t.status", "3")
    );

    list.forEach(System.out::println);
}

运行结果与之前完全相同，需要注意的是，这样写时在引用表名时不要使用数据库中的原表名，主表默认使用t，其他表使用join语句中我们为它起的别名，如果使用原表名在运行中会出现报错。

并且，在MPJQueryWrapper中，可以更灵活的支持子查询操作，如果业务比较复杂，那么使用这种方式也是不错的选择。

分页查询

mpj中也能很好的支持列表查询中的分页功能，首先我们要在项目中加入分页拦截器：

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor(){
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
    return interceptor;
}

接下来改造上面的代码，调用selectJoinPage()方法：

public void page() {
    IPage<OrderDto> orderPage = orderMapper.selectJoinPage(
      new Page<OrderDto>(2,10),
      OrderDto.class,
      new MPJLambdaWrapper<Order>()
        .selectAll(Order.class)
        .select(Product::getUnitPrice)
        .selectAs(User::getName, OrderDto::getUserName)
        .selectAs(Product::getName, OrderDto::getProductName)
        .leftJoin(User.class, User::getId, Order::getUserId)
        .leftJoin(Product.class, Product::getId, Order::getProductId)
        .orderByAsc(Order::getId));

    orderPage.getRecords().forEach(System.out::println);
}

注意在这里需要添加一个分页参数的Page对象，我们再执行上面的代码，并对日志进行解析，查看sql语句：

可以看到底层通过添加limit进行了分页，同理，MPJQueryWrapper也可以这样进行分页。

最后

经过简单的测试，个人感觉mpj这款工具在联表查询方面还是比较实用的，能更应对项目中不是非常复杂的场景下的sql查询，大大提高我们的生产效率。当然，在项目的issues中也能看到当前版本中也仍然存在一些问题，希望在后续版本迭代中能继续完善。

作者：码农参上
来源：juejin.cn/post/7173493838143553549

背景

恰逢最近准备写一个跨框架组件库（工作量很大，前端三个小伙伴利用空闲时间在卷，待组件库完善后会分享给大家，敬请期待），需要学习发布npm包，昨天就想着利用空闲时间把之前写的去除重复请求的axios封装发布为npm包，便于代码复用，回馈社区的同时也能学以致用。

阅读本文，你将收获：

1. 从0开始创建并发布npm的全过程

2. 一个持续迭代且简单实用的axios请求去重工具库

工具库准备

创建一个新项目，包含package.json

{
    "name": "drrq",
    "type": "module",
    "version": "1.0.0"
}

功能实现 /src/index.js

npm i qs axios

主要思路是用请求的url和参数作为key记录请求队列，当出现重复请求时，打断后面的请求，将前面的请求结果返回时共享给后面的请求。

import qs from "qs";
import axios from "axios";

let pending = []; //用于存储每个ajax请求的取消函数和ajax标识
let task = {}; //用于存储每个ajax请求的处理函数，通过请求结果调用，以ajax标识为key

//请求开始前推入pending
const pushPending = (item) => {
    pending.push(item);
};
//请求完成后取消该请求，从列表删除
const removePending = (key) => {
    for (let p in pending) {
        if (pending[p].key === key) {
            //当前请求在列表中存在时
            pending[p].cancelToken(); //执行取消操作
            pending.splice(p, 1); //把这条记录从列表中移除
        }
    }
};
//请求前判断是否已存在该请求
const existInPending = (key) => {
    return pending.some((e) => e.key === key);
};

// 创建task
const createTask = (key, resolve) => {
    let callback = (response) => {
        resolve(response.data);
    };
    if (!task[key]) task[key] = [];
    task[key].push(callback);
};
// 处理task
const handleTask = (key, response) => {
    for (let i = 0; task[key] && i < task[key].length; i++) {
        task[key][i](response);
    }
    task[key] = undefined;
};

const getHeaders = { 'Content-Type': 'application/json' };
const postHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
const fileHeaders = { 'Content-Type': 'multipart/form-data' };

const request = (method, url, params, headers, preventRepeat = true, uploadFile = false) => {
    let key = url + '?' + qs.stringify(params);
    return new Promise((resolve, reject) => {
        const instance = axios.create({
            baseURL: url,
            headers,
            timeout: 30 * 1000,
        });

        instance.interceptors.request.use(
            (config) => {
                if (preventRepeat) {
                    config.cancelToken = new axios.CancelToken((cancelToken) => {
                        // 判断是否存在请求中的当前请求 如果有取消当前请求
                        if (existInPending(key)) {
                            cancelToken();
                        } else {
                            pushPending({ key, cancelToken });
                        }
                    });
                }
                return config;
            },
            (err) => {
                return Promise.reject(err);
            }
        );

        instance.interceptors.response.use(
            (response) => {
                if (preventRepeat) {
                    removePending(key);
                }
                return response;
            },
            (error) => {
                return Promise.reject(error);
            }
        );

        // 请求执行前加入task
        createTask(key, resolve);

        instance(Object.assign({}, { method }, method === 'post' || method === 'put' ? { data: !uploadFile ? qs.stringify(params) : params } : { params }))
            .then((response) => {
                // 处理task
                handleTask(key, response);
            })
            .catch(() => {});
    });
};

export const get = (url, data = {}, preventRepeat = true) => {
    return request('get', url, data, getHeaders, preventRepeat, false);
};
 export const post = (url, data = {}, preventRepeat = true) => {
     return request('post', url, data, postHeaders, preventRepeat, false);
 };
 export const file = (url, data = {}, preventRepeat = true) => {
     return request('post', url, data, fileHeaders, preventRepeat, true);
 };
export default { request, get, post, file };

新增示例代码文件夹/example

示例入口index.js

import { exampleRequestGet } from './api.js';
const example = async () => {
    let res = await exampleRequestGet();
    console.log('请求成功 ');
};
example();

api列表api.js

import { request } from './request.js';
// 示例请求Get
export const exampleRequestGet = (data) => request('get', '/xxxx', data);

// 示例请求Post
export const exampleRequestPost = (data) => request('post', '/xxxx', data);

// 示例请求Post 不去重
export const exampleRequestPost2 = (data) => request('post', '/xxxx', data, false);

// 示例请求Post 不去重
export const exampleRequestFile = (data) => request('file', '/xxxx', data, false);

全局请求封装request.js

import drrq from '../src/index.js';
const baseURL = 'https://xxx';

// 处理请求数据  （拼接url，data添加token等） 请根据实际情况调整
const paramsHandler = (url, data) => {
    url = baseURL + url;
    data.token = 'xxxx';
    return { url, data };
};

// 处理全局接口返回的全局处理相关逻辑  请根据实际情况调整
const resHandler = (res) => {
    // TODO 未授权跳转登录，状态码异常报错等
    return res;
};

export const request = async (method, _url, _data = {}, preventRepeat = true) => {
    let { url, data } = paramsHandler(_url, _data);
    let res = null;
    if (method == 'get' || method == 'GET' || method == 'Get') {
        res = await drrq.get(url, data, preventRepeat);
    }
    if (method == 'post' || method == 'POST' || method == 'Post') {
        res = await drrq.post(url, data, preventRepeat);
    }
    if (method == 'file' || method == 'FILE' || method == 'file') {
        res = await drrq.file(url, data, preventRepeat);
    }
    return resHandler(res);
};

测试功能

代码写完后，我们需要验证功能是否正常，package.json加上

    "scripts": {
        "test": "node example"
    },

执行npm run test

功能正常，工具库准备完毕。

（eslint和prettier读者可视情况选用）

打包

一般项目的打包使用webpack，而工具库的打包则使用rollup

安装 Rollup

通过下面的命令安装 Rollup:

npm install --save-dev rollup

创建配置文件

在根目录创建一个新文件 rollup.config.js

export default {
  input: "src/index.js",
  output: {
    file: "dist/drrp.js",
    format: "esm",
    name: 'drrp'
  }
};

• input —— 要打包的文件

• output.file —— 输出的文件 (如果没有这个参数，则直接输出到控制台)

• output.format —— Rollup 输出的文件类型

安装babel

如果要使用 es6 的语法进行开发，还需要使用 babel 将代码编译成 es5。因为rollup的模块机制是 ES6 Modules，但并不会对 es6 其他的语法进行编译。

安装模块

rollup-plugin-babel 将 rollup 和 babel 进行了完美结合。

npm install --save-dev rollup-plugin-babel@latest

npm install --save-dev @babel/core 

npm install --save-dev @babel/preset-env

根目录创建 .babelrc

{

    "presets": [

      [

        "@babel/preset-env",

        {

          "modules": false

        }

      ]

    ]

}

兼容 commonjs

rollup 提供了插件 rollup-plugin-commonjs，以便于在 rollup 中引用 commonjs 规范的包。该插件的作用是将 commonjs 模块转成 es6 模块。

rollup-plugin-commonjs 通常与 rollup-plugin-node-resolve 一同使用，后者用来解析依赖的模块路径。

安装模块

npm install --save-dev rollup-plugin-commonjs rollup-plugin-node-resolve

压缩 bundle

添加 UglifyJS 可以通过移除注上释、缩短变量名、重整代码来极大程度的减少 bundle 的体积大小 —— 这样在一定程度降低了代码的可读性，但是在网络通信上变得更有效率。

安装插件

用下面的命令来安装 rollup-plugin-uglify：

npm install --save-dev rollup-plugin-uglify

完整配置

rollup.config.js 最终配置如下

import resolve from 'rollup-plugin-node-resolve';

import commonjs from 'rollup-plugin-commonjs';

import babel from 'rollup-plugin-babel';

import { uglify } from 'rollup-plugin-uglify';

import json from '@rollup/plugin-json'



const paths = {

    input: {

        root:  'src/index.js',

    },

    output: {

        root:  'dist/',

    },

};



const fileName = `drrq.js`;



export default {

    input: `${paths.input.root}`,

    output: {

        file: `${paths.output.root}${fileName}`,

        format: 'esm',

        name: 'drrq',

    },

    plugins: [

        json(),

        resolve(),

        commonjs(),

        babel({

            exclude: 'node_modules/**',

            runtimeHelpers: true,

        }),

        uglify(),

    ],

};

在package.json中加上

"scripts": {

    "build": "rollup -c"

},

即可执行npm run build将/src/index.js打包为/dist/drrq.js

发包前的准备

准备npm账号，通过npm login或npm adduser。这里有一个坑，终端内连接不上npm源，需要在上网工具内复制终端代理命令后到终端执行才能正常连接。

准备一个简单清晰的readme.md

修改package.json

完整的package.json如下

{
    "name": "drrq",
    "private": false,
    "version": "1.3.5",
    "main": "/dist/drrq.js",
    "repository": "https://gitee.com/yuanying-11/drrq.git",
    "author": "it_yuanying",
    "license": "MIT",
    "description": "能自动取消重复请求的axios封装",
    "type": "module",
    "keywords": [
        "取消重复请求",
    ],
    "dependencies": {
        "axios": "^1.2.0",
        "qs": "^6.11.0"
    },
    "scripts": {
        "test": "node example",
        "build": "rollup -c"
    },
    "devDependencies": {
       ...
    }
}

• name 包名称 一定不能与npm已有的包名重复，想一个简单易记的

• private 是否为私有

• version 版本

• main 入口文件位置

• repository git仓库地址

• author 作者

• license 协议

• description 描述

• keywords 关键词，便于检索

每个 npm 包都需要一个版本，以便开发人员在安全地更新包版本的同时不会破坏其余的代码。npm 使用的版本系统被叫做 SemVer，是 Semantic Versioning 的缩写。

不要过分担心理解不了相较复杂的版本名称，下面是他们对基本版本命名的总结： 给定版本号 MAJOR.MINOR.PATCH，增量规则如下：

1. MAJOR 版本号的变更说明新版本产生了不兼容低版本的 API 等，

2. MINOR 版本号的变更说明你在以向后兼容的方式添加功能，接下来

3. PATCH 版本号的变更说明你在新版本中做了向后兼容的 bug 修复。

表示预发布和构建元数据的附加标签可作为 MAJOR.MINOR.PATCH 格式的扩展。

最后，执行npm publish就搞定啦

本文的完整代码已开源至gitee.com/yuanying-11… ,感兴趣的读者欢迎fork和star！

另外，本文参考了juejin.cn/post/684490… 和juejin.cn/post/684490…

作者：断律绎殇
来源：juejin.cn/post/7172240485778456606

那天早晨，我冲进总经理的办公室，发现人力资源总监也在，我说：真巧，真好，两位都在，我要辞职！

我在马路上走着，头脑有些昏昏沉沉的。

“大爷，我有故事你听听吗？”，扫马路的大爷没理我，提起垃圾桶，走了。

“阿姨，你想听听我的经历不？”，等公交的大妈拦下一辆出租车，走了。

算了，年中总结到了，我就谈一谈我的上半身……上半生……不是，上半年吧。

一、十年职场终一梦，互联网里心不平

2022年，是我工作的第11年，这11年，我都在互联网中沉浮，而且一直是向着风口奔跑。

我一开始处于电信增值行业，我们叫SP业务。

现在的年轻人可能很难想象，以前的互动主要靠短信，就是1毛钱一条的短信。

比如某电视台有个话题，对于一个事件你是支持还是反对，如果支持发短信1，反对发送2。

这时候，发送一条短信的定价可以自己设置，比如2元1条，在运营商那里备个案就行，当时来说，这是合法的。

一般为了提高发短信的积极性，都会在最后搞一个抽奖，抽中之后送套茶壶啥的，这样，两块钱也就舍得花了。

因为自己有定价的权利，所以可玩的就有很多。

比如：

我做一个游戏嵌到手机里，想玩就发短信啊。

再比如：

我提供一个服务，每天给你发送天气预报信息，想订阅就发短信啊。

2011年，随着智能手机的兴起，短信有被网络消息取代的趋势，而且乱收费也受到了监管。

所以，一些SP企业就纷纷转型移动互联网，去做智能手机应用。

我此时毕业，因为学的就是智能手机应用开发专业，而且大学期间也自己搞了一些和iOS的APP去运作，所以很顺利地就找到工作。

这一干就是5年，搞过手机游戏，搞过订餐系统，搞过电商，搞过O2O，搞过政务……因为企业转型，一般没有目标，什么火就搞什么。

后来，我感觉干的太乱了，自己应该抓住一个行业去搞，于是在2016年就去了另一家公司，主要做在线教育平台。

所有公司都一样，一个公司干久了，职位自然会提升，因为人都熬走了，只剩下你了，另外你跟各部门都熟，工作推进起来也方便。

我也是这么一步一步走过来，从普通开发到技术组长，从技术组长到技术经理，从技术经理再到项目经理。

工作内容也是越来越杂：

• 普通开发时，只写客户端代码就可以。

• 负责技术时，因为客户端嵌入了H5页面，客户端要调服务端的接口，所以我也学会了前端和后端的开发。实际工作中，你会发现，你不了解一线的实际操作，你是心虚的，你没法避免别人糊弄你，你也无法更公正地解决争端，所谓的什么“道理都是相通的”、“能管理好煤炭企业，也能管理好体育企业”这类管理理论，只是作为管理者懒政的借口。

• 负责项目时，需要对产品原型、UI设计进行一个把握，需要对前期需求和后期售后进行一个兼顾，出个差，陪个酒也是常有的事情。有时候，哪里有空缺了，比如没有人设计原型，那么就要自己顶上去。

整体下来，自己基本上达到这么一种情况：做一个互联网项目，从需求到上线，如果有更专业的人，那么能干的更快更好，如果只有自己，也能磕磕碰碰地完成。

这种技能就是，要说没有本事吧，好像还能干不少事情。要说有本事呢，还真没有一样可以拿出手的绝活。

但是，这不重要。

我更关注的是，我供职的几家公司，包括身边的互联网公司，做产品也好，做平台也罢，都没有实现盈利。

此处需要解释一下，我心中的盈利是指传统的盈利，就是通过销售的方式，产生了大于成本的收入，比如这软件花5块钱做的，卖了10块钱。

我供职的公司，基本上都融过资，从百万到千万都有，都是拿着一份未来的规划，就有人投钱。

没有实现盈利，却依然可以持续地生存下去，我认为这不是一种常态。

看不到自己的作品实打实地变现，我是心虚的。

十年互联网一场梦，看着一波又一波游走在风口的企业，虽然从没有耽误过我拿薪水，但是我却是担惊受怕的：

• 这是泡沫吗？

• 会破吗？

• 哪一天会到来？

• 我这10年的积累稳不稳定？

二、裁员浪潮突袭来，转行意识在徘徊

上半年，大家还在期待着加薪，没想到等到的是裁员。

还好，我是项目负责人，因为平时工作表现还可以，所以不裁我。不但不裁我，还给我升职加薪。

但是，我也面临了一个问题：你裁谁？

我刚上任，哪里知道该裁谁，就这么推推搡搡，确定了一个名单。

裁人那天早上，我推门去找总经理，我说我要辞职了，于是就出现了开头的那一幕。

我走在街上，我觉得这是一个经过反复思考后的决定。

可能很多人觉得，疫情期间，能有一份工作不就挺好吗？

但是，我还考虑到了未来。

三十多岁的人了，只考虑眼下的工作吗？问过自己要什么吗？

1、你处的行业怎么样？
  教育行业，崩盘式堕落。
2、行业不行，公司有发展也可以啊，你公司发展怎么样？
  失去方向，驱逐人员。
3、公司不佳，工作内容有前途也可以，你的工作有没有挑战？
  重复性工作，得心应手。
复制代码

好像只剩下钱了，但是这钱，还能挣多久，现在挣得心虚吗？

不只是我这么想，我身边好多人都这么想。

于是，戏剧性的一幕发生了。

大家开始纷纷转行了，这个转行只是小转行，指的是IT行业内的工种转行。

• 做前端开发的开始转行做后端开发。

• 做后端开发的开始转行做项目管理。

• 做项目管理的开始转行做产品管理。

有时候我在想，这个问题是转行就能破局的吗？

是跟整体经济形势有关呢，还是跟个人职业匹配有关呢，说不好，不好说，好像只能试试看了。

其实，我也准备转行了，从项目管理转向人工智能开发。

我从2018年开始，出于兴趣，就已经开始学习人工智能了，我认为写逻辑代码的顶峰就是无逻辑，那就是神经网络，就是人工智能。

4年的学习，也有了一些实践和应用，也该宝刀出鞘了。

三、出去面试吓一跳，行业经验很重要

我先是奔着人工智能算法工程师去投简历，但是我的简历太复杂了，啥都干过，起初我还认为这是优势。

直到碰到一个招聘主管点醒了我，她居然还是我的学姐，她说你把算法部分抽出来吧，面试啥岗位就写啥经历。

我一想也对，以前自己也当过面试官，一般除非管理岗位，大公司都比较看重专业性，你招聘一个Android开发，结果简历上80%写的是PHP，这不合适。

我把其他项目都删除了，只保留算法相关的应用案例，基本上都是应用在教育教学方面的。

后来，面试机会真的多了。

但是问题也来了，这些招聘的企业，有的是搞煤炭的，有的是搞养殖的，你与他们很难对上话。

比如他们说一个“倒线”，你听不明白，他们都觉得很奇怪，这不是行业基础知识吗？他们认为你应该明白。

再后来，我还是决定去教育行业试试，这一去不要紧，一发不可收拾，什么“教材”、“章节”、“知识点”、“题库”、“资源”、“备授课”，搞了多少年了，而且既全面又深度。

最后，我还是选择了一家做算法的教育企业，这将作为我算法职业生涯的起点。

你看，是否教育行业已经不重要了，重要的是算法这个职业，这就是除了钱之外，我们另外追求的点。

四、人到中年再重启，空杯心态学到底

这次我选择了做一名小职员，最最底层那种普通开发。

原因是你选择了算法，那么以你在算法领域的资历，当不了管理。

强行做，是会有问题的，所谓：德不配位，必有灾殃。

而我也很坦然，做管理这么多年，沉下心来，踏踏实实学习一两年，不好吗？

入职新公司这两个月，我感受到了从来没有过的舒适，没有了没完没了的会议，没有了上午说完中午就交的方案，也没有了深夜打来处理现场问题的电话，只有我深爱的算法代码。

而且，通过实际的项目，也让我对算法有了更深的见解，这两个月的收获也远远超过之前的两年。

挺好的，善于舍得就会有更多的收获。

相信我通过几年的学习，再结合之前杂七杂八的经验，最终在人工智能产业方面可以做出一定的成绩，这也是我最新的规划。

看见没有，人一旦有了新的希望，就有了动力。