支持的面向对象特性：

1. 封装

1
2
3
4
5
6
7
8
9

type person struct {
    name string  // 小写私有
    Age  int     // 大写公开
}

// 方法封装
func (p *person) GetName() string {
    return p.name
}

2. 多态（通过接口实现）

1
2
3
4
5
6
7
8
9
10
11
12
13
14

type Animal interface {
    Speak() string
}

type Dog struct{}
type Cat struct{}

func (d *Dog) Speak() string { return "Woof!" }
func (c *Cat) Speak() string { return "Meow!" }

// 多态使用
func MakeSound(a Animal) string {
    return a.Speak()
}

3. 组合（代替继承）

1
2
3
4
5
6
7
8

type Engine struct {
    Power int
}

type Car struct {
    Engine  // 通过组合获得Engine的能力
    Brand string
}

不支持的面向对象特性：

1. 继承
   • Go 语言不支持类和继承
   • 使用组合代替继承
   • 没有 extends 或 class 关键字
2. 构造函数
   • 没有专门的构造函数语法
   • 通常使用工厂函数模式

1
2
3
4
5

// 显式的错误处理
result, err := SomeFunction()
if err != nil {
    // 处理错误
}

3. 方法重载
   • 不支持同名不同参数的方法
   • 每个方法名必须唯一
4. 泛型（Go 语言 1.18 之前）
   • 早期版本完全不支持泛型
   • Go 语言 1.18 后添加了泛型支持

Go 语言的设计理念：

1. 简单性
   • 语言特性较少
   • 避免特性重叠
   • 语法简洁明了
2. 实用性
   • 注重工程实践
   • 关注并发编程
   • 快速编译
3. 组合优于继承

1
2
3
4
5

// 优先使用组合
type Writer struct {
    Buffer *bytes.Buffer
}
// 而不是继承

4. 显式优于隐式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 使用组合和接口
type Service interface {
    Process() error
}

type BaseService struct {
    name string
}

type SpecificService struct {
    BaseService
    // 特定字段
}

// 实现接口
func (s *SpecificService) Process() error {
    // 实现逻辑
    return nil
}

总结：

1. Go 语言不是传统意义上的面向对象语言
   • 没有类的概念
   • 不支持继承
   • 没有对象实例的概念
2. Go 语言是多范式语言
   • 支持过程式编程
     • 支持部分面向对象特性
   • 支持函数式编程特性
3. Go 语言的设计特点
   • 简单性和实用性
   • 组合优于继承
   • 接口隐式实现
   • 强调代码的清晰和可维护性
4. 实际应用建议

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 使用组合和接口
type Service interface {
    Process() error
}

type BaseService struct {
    name string
}

type SpecificService struct {
    BaseService
    // 特定字段
}

// 实现接口
func (s *SpecificService) Process() error {
    // 实现逻辑
    return nil
}

所以，与其说 Go 语言是不是面向对象语言，不如说 Go 语言提供了一种独特的方式来处理程序设计中的问题，它汲取了面向对象编程的优点，但避免了传统 OOP 中的一些复杂性和限制。这种设计使得 Go 语言特别适合构建大型、可维护的系统，尤其是在云计算和网络服务领域

1. venv

venv 是 Python 标准库自带的虚拟环境管理工具，从 Python 3.3 开始内置支持。

特点

• 轻量级：venv 是一个简单的工具，专注于创建和管理 Python 虚拟环境。
• 无需额外安装：因为是 Python 自带的功能，所以不需要额外安装其他软件。
• 纯 Python 环境：venv 创建的虚拟环境仅包含 Python 解释器及其依赖包，适合纯 Python 项目。
• 依赖管理工具：通常与 pip 配合使用来管理包。

优点

• 使用简单，开箱即用。
• 对于纯 Python 项目来说足够高效。
• 不需要额外学习成本，适合初学者。

缺点

• 不支持非 Python 的依赖（如 C 库等）。
• 环境隔离能力有限，无法管理多语言或复杂的科学计算环境。
• 在 Windows 上配置可能稍显复杂。

2. Conda

Conda 是一个跨平台的包管理和环境管理工具，最初由 Anaconda 团队开发，广泛应用于数据科学和机器学习领域。

特点

• 强大的包管理功能：不仅支持 Python 包，还支持非 Python 的依赖（如 C、R 等）。
• 环境隔离：可以创建完全独立的环境，包括 Python 版本和其他系统依赖。
• 跨平台支持：对 Windows、macOS 和 Linux 都有良好的支持。
• 生态系统丰富：Anaconda 提供了大量预编译的科学计算和数据分析包。

优点

• 支持多语言和复杂依赖的项目。
• 对科学计算和机器学习友好，许多常用库（如 NumPy、SciPy、TensorFlow 等）已经经过优化并预编译。
• 提供图形化界面（Anaconda Navigator），适合不熟悉命令行操作的用户。
• 更好的性能优化，尤其是在处理大型数据集时。

缺点

• 安装体积较大，尤其是完整版的 Anaconda。
• 对于纯 Python 项目来说可能显得过于复杂。
• 某些情况下，conda 和 pip 的兼容性问题可能导致包管理混乱。

如何选择？

选择 venv 的场景

1. 纯 Python 项目：如果项目只涉及 Python 代码，且依赖较为简单，venv 是更好的选择。
2. 轻量级需求：如果你希望快速搭建环境，且不想引入额外的工具或依赖，venv 是更轻便的选择。
3. 熟悉命令行操作：对于习惯使用命令行工具的开发者，venv 提供了简单直接的接口。

选择 Conda 的场景

1. 数据科学和机器学习项目：如果你从事数据科学、机器学习或深度学习相关的工作，Conda 的生态系统会显著提升效率。
2. 复杂依赖管理：当项目需要安装非 Python 的依赖（如 C 库、R 包等），或者需要特定版本的系统库时，Conda 更加适合。
3. 跨平台开发：如果你需要在不同操作系统之间切换，Conda 提供了更好的一致性和兼容性。
4. 新手友好：对于不熟悉命令行操作的用户，Conda 提供了图形化界面（Anaconda Navigator），降低了学习门槛。

总结对比表

实际建议

• 如果你是 Python 初学者，或者项目比较简单，推荐使用 venv。
• 如果你从事数据科学、机器学习或其他需要复杂依赖管理的工作，推荐使用 Conda。
• 如果不确定，可以先尝试 venv，遇到复杂需求时再迁移到 Conda。尤其是在云计算和网络服务领域

docker 搭建 keepalived 实现 nginx 双机热备

1
2

❯ docker run --privileged -d --name node1 debian:11 top -b
❯ docker run --privileged -d --name node2 debian:11 top -b

–-privileged 是指以特权模式启动容器，否则 keepalived 无法成功生成虚拟 IP

分别进入 node1、node2 容器节点（docker exec -it node1 /bin/bash 和 docker exec -it node2 /bin/bash ）

安装以下软件 apt update && apt install curl vim iproute2 inetutils-ping psmisc net-tools systemctl nginx keepalived -y

创建以下两个文件：

vi /etc/keepalived/chk_nginx.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#!/bin/bash
echo $(date) "start check nginx..." >> /etc/keepalived/check_nginx.log

counter=$(systemctl status nginx | grep running | wc -l)
if [ "${counter}" = "0"  ]; then
   echo $(date)  "nginx is not running, restarting..." >> /etc/keepalived/check_nginx.log
   systemctl start nginx
   sleep 2
   counter=$(systemctl status nginx | grep running | wc -l)
   if [ "${counter}" =  "0" ]; then
      echo $(date) "nginx is down, kill all keepalived..." >> /etc/keepalived/check_nginx.log
      killall keepalived
   fi
fi

脚本作用是查看是否存在 nginx 进程，不存在就重启 nginx，然后再查看一次，还不存在就杀掉 keepalived 进程（这样备既就会自动上线）
脚本权限需设置为 755（chmod 755 /etc/keepalived/chk_nginx.sh），否则 keepalived 会认为它不安全
注意首行一定是 #!/bin/bash，而不是 #/bin/bash，否则脚本不会被 keepalived 执行

node1 容器节点为虚拟 IP 172.17.0.201 的主节点、虚拟IP 172.17.0.202 的备用节点， keepalived 配置文件如下：

vi /etc/keepalived/keepalived.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

! Configuration File for keepalived

global_defs {
    router_id localhost
    script_user root
    enable_script_security
}

vrrp_script chk_http_port {
    script /etc/keepalived/chk_nginx.sh
    interval 10 # 间隔几秒执行脚本（注意最好大于脚本的执行时间）
    weight -20
}

vrrp_instance VI_1 {
    state MASTER # 1、备机改为：BACKUP
    interface eth0 # 2、替换为实际网卡名称，可使用 ifconfig 或 ip addr 查看
    virtual_router_id 51
    priority 100 # 3、备机优先级设置小一点，例如：90
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    track_script {
       chk_http_port
    }
    virtual_ipaddress {
        172.17.0.201 # 虚拟 IP（和 node1、node2 容器节点在同一网段的任意闲置 IP 即可）
    }
}

vrrp_instance VI_2 {
    state BACKUP
    interface eth0 #
    virtual_router_id 52
    priority 90
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    track_script {
       chk_http_port
    }
    virtual_ipaddress {
        172.17.0.202
    }
}

node2 容器节点为虚拟 IP 172.17.0.202 的主节点、虚拟IP 172.17.0.201 的备用节点， keepalived 配置文件如下：

vi /etc/keepalived/keepalived.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

! Configuration File for keepalived

global_defs {
    router_id localhost
    script_user root
    enable_script_security
}

vrrp_script chk_http_port {
    script /etc/keepalived/chk_nginx.sh
    interval 10
    weight -20
}

vrrp_instance VI_1 {
    state BACKUP
    interface eth0
    virtual_router_id 51
    priority 90
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    track_script {
       chk_http_port
    }
    virtual_ipaddress {
        172.17.0.201
    }
}

vrrp_instance VI_2 {
    state MASTER
    interface eth0
    virtual_router_id 52
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    track_script {
       chk_http_port
    }
    virtual_ipaddress {
        172.17.0.202
    }
}

node1 和 node2 容器节点互为主备， keepalived 配置文件除过注释标注的 3 处不同外，其余配置项保持一致即可
可使用 keepalived -t 检测配置文件是否有误

为了验证主备切换效果，可分别在主备 nginx 默认界面添加不同信息加以区分（vi /var/www/html/index.nginx-debian.html）

1、分别启动 node1 和 node2 容器节点的 keepalived（systemctl start keepalived）

2、在 node1 节点容器使用 ifconfig 或 ip addr 命令可看到绑定的虚拟 IP 172.17.0.201，此时通过访问虚拟 IP：curl http://172.17.0.201 展示的是 node1 节点的 nginx 信息

3、在 node2 节点容器使用 ifconfig 或 ip addr 命令可看到绑定的虚拟 IP 172.17.0.202，此时通过访问虚拟 IP：curl http://172.17.0.202 展示的是 node2 节点的 nginx 信息

4、故意改错 node1 上的 nginx 配置文件让其无法启动，并且停止 nginx（systemctl stop nginx）（模拟宕机情况），node1 节点的 keepalived 检测到 nginx 进程不存在，然后尝试启动 nginx，发现启动失败，所以会杀掉 keepalived 进程，释放虚拟 IP 172.17.0.201

5、node2 节点 keepalived 感知到 node1 节点下线后会绑定虚拟 IP 172.17.0.201 接管请求，完成主备切换。此时在 node2 节点容器使用 ifconfig 或 ip addr 命令可看到绑定的虚拟 IP 172.17.0.201 和 172.17.0.202，此时通过访问 curl http://172.17.0.201 和 curl http://172.17.0.201 展示的都是 node2 节点的 nginx 信息

6、当恢复 node1 节点 nginx 配置文件并重新加载，然后启动 keepalived，在 node1 容器节点使用 ifconfig 或 ip addr 命令可再次看到绑定的虚拟 IP 172.17.0.201，此时通过访问 curl http://172.17.0.201 展示的又是 node1 节点的 nginx 信息，访问 curl http://172.17.0.201 展示的是 node2 节点的 nginx 信息

左右指针法实现思路

1、首先定义分区点（pivot）p，p 一般为数组 a 的第一个元素或最后一个元素
2、然后定义左（l）、右（r）两个指针分别指向数组的第一个元素（a[0]）和最后一个元素 (a[a.length - 1])
3、如果 a[l] > a[p]，l、p 下标元素互换，l 前进 1 位
4、如果 a[r] < a[p]，r、p 下标元素互换，r 后退 1 位
5、如果 l >= r，排序结束

快速排序左右指针法图解过程

代码实现

以递归方式实现编码，首先找出分析出递归条件：

1、递归方程：quickSort(a[l..r]) = quickSort(a[l..p-1]) + quickSort(a[p+1..r])
2、递归退出条件：l >= r

注意点：如果选择分区点 p = l，必须先从右边找到小于 a[p] 的第一个元素开始

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

/**
 * 快速排序
 *
 * @param a 待排序数组
 * @param l 第一个元素下标
 * @param r 最后一个元素下标
 */
public static void sort(int[] a, int l, int r) {
  if (a == null || l >= r) {
    return;
  }

  int i = l, j = r;
  int p = l; // 选择最左边的元素为 pivot
  while (l < r) {
    // 如果选择 p = l 必须先从右边找到小于 a[p] 的第一个元素
    while (l < r && a[r] >= a[p]) {
      r--;
    }
    swap(a, r, p);
    p = r;

    // 从左边找到大于 a[p] 的第一个元素
    while (l < r && a[l] <= a[p]) {
      l++;
    }
    swap(a, l, p);
    p = l;
    System.out.println(Arrays.toString(a));
  }

  sort(a, i, p - 1);
  sort(a, p + 1, j);
}

public static swap(int[] a, int i, int j) {
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
}

翻译成代码如下：

1
2
3
4
5
6
7

public void sort(int a) {
    for(int i = a.length - 1; i > 0; i--) {
        buildHeap(a, i);
        // 堆顶元素和最后一个元素交换，除过最后一个元素外其它元素再次构建大顶堆
        swap(a, 0, i);
    }
}

堆化过程

1、从序列最后一个非叶子节点开始
2、堆化规则：替换节点为当前节点和叶子节点中值最大的节点
3、倒序依次处理其它非叶子节点
4、须保证叶子节点也满足堆化规则

前置知识

1、堆是完全二叉树
2、满二叉树使用数组存储最省空间
3、若节点在数组中的下标为 n，其左叶子节点在数组中的下标为 2 * n + 1，右子节点下标为 2 * n + 2，父节点下标为 (n - 2)/2

堆化过程图解

翻译成代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

/**
 * 构建大顶堆
 *
 * @param a 数组
 * @param n 最后一个元素下标
 */
public static void buildHeap(int[] a, int n) {
    // 从最后一个非叶子节点开始，倒序依次处理其它非叶子节点
    for(int i = (n -1) / 2; i >=0; i--) {
        heapify(a, n, i);
    }
}

/**
 * 堆化
 *
 * @param a 数组
 * @param n 最后一个元素下标
 * @param i 需要调整的父节点下标
 */
public static void heapify(int[] a,int n, int i) {
    while (true) {
        // 大顶堆规则：替换节点为当前节点和叶子节点中值最大的节点
        int maxPos = i;

        int l = 2 * i + 1;
        if (a[l] > a[maxPos]) {
            maxPos = l;
        }

        int r = 2 * i + 2;
        if (a[r] > a[maxPos]) {
            maxPos = r;
        }

        // 当前节点最大时退出
        if (maxPos == i) {
            return;
        }

        swap(a, maxPos, i);

        // 保证叶子节点也满足堆化规则
        i = maxPos;
    }
}

public static void swap(int[] a, int i, int j) {
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
}

• 字符串前缀(Proper prefix) ：包含第一个字符，不包含最后一个字符的所有子串
  例如：abababca 的前缀：a、ab、aba、abab、ababa、ababab、abababc

• 字符串后缀(Proper suffix)：不包含第一个字符，包含最后一个字符的所有子串
  例如：abababca 的后缀：a、ca、bca、abca、babca、ababca、bababca

字符串部分匹配表

字符串部分匹配表 (Partial Match Table) 也称为 next 数组，例如：abababca 的部分匹配表为：

每列 value 值表示前 index + 1 个字符子串的最大字符串前缀与字符串后缀相匹配的长度，例如：

• index 为 0 的子串为 a，没有字符串前缀和字符串后缀，所以 value 为 0
• index 为 1 的子串为 ab，字符串前缀为 a，字符串后缀为 b，没有相匹配的字符串前缀与字符串后缀，所以 value 为 0
• index 为 2 的子串为 aba，字符串前缀为 a、ab，字符串后缀为 a、ba，字符串前缀与字符串后缀相匹配的子串为 a，长度为 1，所以 value 为 1
• index 为 3 的子串为 abab，字符串前缀为 a、ab、aba，字符串后缀为 b、ab、bab，字符串前缀与字符串后缀相匹配的子串为 ab，长度 2，所以 value 为 2
• index 为 4 的子串为 ababa，字符串前缀为 a、ab、aba、abab，字符串后缀为 a、ba、aba、baba，字符串前缀与字符串后缀相匹配的子串为 a、aba，长度最大的为 aba ，所以 value 为 3
• …
• index 为 7 的子串为 abababca，字符串前缀为 a、ab、aba、abab、ababa、ababab、abababc，字符串后缀为 a、ca、bca、abca、babca、ababca、bababca，字符串前缀与字符串后缀相匹配的子串为 a，所以 value 为 1

KMP 算法思路

KMP 算法就是利用字符串部分匹配表可以计算出当模式串与主串不匹配时，模式串可以多后移几位 (默认后移 1 位)

当模式串与主串不匹配时，如果不匹配字符对应模式串下标大于 0 (非首个模式串字符)，取此字符前一个字符对应字符串部分匹配表中的 value ，如果 value 大于 0，模式串中不匹配字符之前 (不含不匹配字符) 子串长度减去 value 即模式串为后移的位数。

暴力匹配算法当模式串和主串不匹配时，主串匹配下标 +1，模式串匹配下标置为 0，KMP 算法优化点在于模式串匹配下标置为 value。

例如在主串 bacbababaabcbab 中查找模式串 abababca

• 第一次符合以上规则的情况如下，模式串与主串不匹配字符 (b) 前一个字符为 a，对应字符串部分匹配表 index 为 0，value 为 0，所以不存在多后移情况

1
2
3

bacbababaabcbab
  |
 abababca

• 第二次符合以上规则的情况如下

1
2
3

bacbababaabcbab
         |
    abababca

• 模式串与主串不匹配字符 (b) 前一个字符是 a，对应字符串部分匹配表 index 为 4，value 为 3，不匹配字符之前模式串为 ababa 长度为 5， 所以后移 5-3=2 位

1
2
3

bacbababaabcbab
         |
      abababca

• 模式串与主串不匹配字符 (b) 前一个字符是 a，对应字符串部分匹配表 index 为 2，value 为 1，不匹配字符之前模式串为 aba 长度为 3， 所以后移 3-1=2 位

1
2
3

bacbababaabcbab
           |
         abababca

• 此时，模式串长度已经比剩余主串长，匹配结束。

代码实现

next 数组的代码实现思路参考 KMP 算法的 Next 数组详解

Golang 暴力匹配代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 暴力匹配
func Bf(s, p string) int {
    n := len(s)
    m := len(p)
    if n < m {
        return -1
    }

    for i := 0; i <= n-m; i++ {
        j := 0
        for j < m {
            // 如果主串与模式串不匹配，则主串向右移动一个字符,模式串从头开始匹配
            if s[i+j] != p[j] {
                break
            }
            j++
        }
        if j == m {
            return i
        }
    }

    return -1
}

Golang KMP 代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

func Kmp(s, p string) int {
    n := len(s)
    m := len(p)
    if n < m {
        return -1
    }
    next := GetNext(p)

    for i := 0; i <= n-m; i++ {
        j := 0
        for j < m {
            // 暴力匹配算法当模式串和主串不匹配时，主串匹配下标 +1，模式串匹配下标置为 0，
            // KMP 算法优化点在于将模式串下标置为不匹配字符前一个字符对应 next 数组的值
            if s[i+j] != p[j] {
                // 当模式串与主串不匹配时，如果不匹配字符对应模式串下标大于 j > 0 (非首个模式串字符)，
                // 并且此字符前一个字符对应字符串部分匹配表中的值 next[j - 1] 也大于 0，
                // j - next[j - 1] 即模式串为后移的位数，等价于 j 置为 next[j - 1]

                if j != 0 && next[j-1] != 0 {
                    // j 后移 j-next[j-1]，等价于 j = next[j-1]
                    j = next[j-1]
                } else {
                    break
                }
            }
            j++
        }
        if j == m {
            return i
        }
    }

    return -1
}

func GetNext(p string) []int {
    n := len(p)
    next := make([]int, n)
    next[0] = 0
    k := 0

    // 根据已知 next 数组的前 i-1 位推测第 i 位
    for i := 1; i < n; i++ {
        for k > 0 && p[k] != p[i] {
            // k 为 p[0, i) 子串最大匹配前后缀长度
            // p[0, k) 为 p[0, i) 子串最大匹配前缀子串

            // 若：1、p[k] != p[i]，则求 p[0, i] 子串最大匹配前后缀长度问题
            // 转换成了求 p[0, k) 子串最大匹配前后缀长度问题
            // 循环直到 p[k] == p[i] (下一步处理) 或 k == 0
            k = next[k]
        }

        // 若：2、p[k] == p[i]，则 p[0, i] 子串最大匹配前后缀长度为 k + 1
        if p[k] == p[i] {
            k++
        }

        next[i] = k
    }
    return next
}

Java KMP 代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

package io.github.ehlxr.algorithm.match;

import java.util.Arrays;

/**
 * 字符串匹配算法 KPM
 *
 * @author ehlxr
 * @since 2022-03-13 10:06.
 */
public class Kmp {
    public static void main(String[] args) {
        String s = "bacbababaabcbab";
        String p = "abab";

        System.out.println(Arrays.toString(getNexts(p)));
        System.out.println(kmp(s, p));
    }

    public static int kmp(String s, String p) {
        char[] scs = s.toCharArray();
        char[] pcs = p.toCharArray();

        int m = s.length();
        int n = p.length();

        int[] next = getNexts(p);

        for (int i = 0; i <= m - n; i++) {
            int j = 0;
            for (; j < n; j++) {
                if (scs[i + j] != pcs[j]) {
                    // 暴力匹配算法当模式串和主串不匹配时，主串匹配下标 +1，模式串匹配下标置为 0，
                    // KMP 算法优化点在于将模式串下标置为不匹配字符前一个字符对应 next 数组的值
                    if (j > 0 && next[j - 1] > 0) {
                        // 当模式串与主串不匹配时，如果**不匹配字符**对应模式串下标大于 j > 0 (非首个模式串字符)，
                        // 并且此字符前一个字符对应字符串部分匹配表中的值 next[j - 1] 也大于 0，
                        // j - next[j - 1] 即模式串为后移的位数，等价于 j 置为 next[j - 1]
                        j = next[j - 1];
                    } else {
                        break;
                    }
                }
            }
            if (j == n) {
                return i;
            }
        }

        return -1;
    }

    private static int[] getNexts(String p) {
        int m = p.length();
        char[] b = p.toCharArray();
        int[] next = new int[m];

        next[0] = 0;
        int k = 0; // 表示前后缀相匹配的最大长度

        // 根据已知 next 数组的前 i-1 位推测第 i 位
        for (int i = 1; i < m; ++i) {
            while (k != 0 && b[k] != b[i]) {
                // k 为 b[0, i) 子串最大匹配前后缀长度
                // b[0, k) 为 b[0, i) 子串最大匹配前缀子串

                // 若：1、b[k] != b[i]，则求 b[0, i] 子串最大匹配前后缀长度问题
                // 转换成了求 b[0, k) 子串最大匹配前后缀长度问题
                // 循环直到 b[k] == b[i] (下一步处理) 或 k == 0
                k = next[k];
            }
            // 若：2、b[k] == b[i]，则 b[0, i] 子串最大匹配前后缀长度为 k + 1
            if (b[k] == b[i]) {
                ++k;
            }
            next[i] = k;
        }
        return next;
    }
}

参考 The Knuth-Morris-Pratt Algorithm in my own words

1. 由于对象一般分配在堆上，而堆是线程共用的，因此可能会有多个线程在堆上申请空间，而每一次的对象分配都必须加锁保证线程同步，会使分配的效率下降。考虑到对象分配几乎是 Java 中最常用的操作，因此 JVM 使用了 TLAB 这样的线程专有区域来避免多线程冲突，提高对象分配的效率。
2. 我们说 TLAB 是线程独享的，但是只是在 “分配” 这个动作上是线程独享的，至于在读取、垃圾回收等动作上都是线程共享的。而且在使用上也没有什么区别
3. JVM 为了提升对象内存分配的效率，对于所创建的线程都会分配一块独立的空间 TLAB，其大小由 JVM 根据运行的情况计算而得，在 TLAB 上分配对象时不需要加锁，因此 JVM 在给线程的对象分配内存时会尽量的在 TLAB 上分配，在这种情况下 JVM 中分配对象内存的性能和 C 基本是一样高效的，但如果对象过大的话则仍然是直接使用堆空间分配
4. 在 TLAB 分配之后，并不影响对象的移动和回收，也就是说，虽然对象刚开始可能通过 TLAB 分配内存，存放在 Eden 区，但是还是会被垃圾回收或者被移到 Survivor Space、Old Gen 等。
5. “堆是线程共享的内存区域” 这句话并不完全正确，因为 TLAB 是堆内存的一部分，它在读取上确实是线程共享的，但是在内存分配上，是线程独享的。
6. TLAB 的空间其实并不大（默认是 eden 区空间的 1%），所以大对象还是可能需要在堆内存中直接分配。那么，对象的内存分配步骤就是先尝试 TLAB 分配，空间不足之后，再判断是否应该直接进入老年代，然后再确定是再 eden 分配还是在老年代分配。

TLAB 对象分配过程

参考链接

• 尚硅谷-宋红康-详解 Java 虚拟机
• JVM 关于对象分配在堆、栈、TLAB 的理解
• TLAB（Thread Local Allocation Buffer）

SQL 标准定义了 4 类隔离级别，包括了一些具体规则，用来限定事务内外的哪些改变是可见的，哪些是不可见的。低级别的隔离级一般支持更高的并发处理，并拥有更低的系统开销。

Read Uncommitted（读取未提交内容）

在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。读取未提交的数据，也被称之为脏读（Dirty Read）。

Read Committed（读取提交内容）

这是大多数数据库系统的默认隔离级别（但不是 MySQL 默认的）。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别 也支持所谓的不可重复读（Nonrepeatable Read），因为同一事务的其他实例在该实例处理其间可能会有新的 commit，所以同一 select 可能返回不同结果。

Repeatable Read（可重读）

这是 MySQL 的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致另一个棘手的问题：幻读 （Phantom Read），简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的 “幻影” 行。

InnoDB 存储引擎通过 MVCC 机制（快照读）和 next-key lock（当前读）解决了该问题。

Serializable（可串行化）

这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。

事务隔离带来的问题

这四种隔离级别采取不同的锁类型来实现，若读取的是同一个数据的话，就容易发生问题。例如：

脏读 (Drity Read)：一个事务读取到另一事务未提交的更新数据。当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中（这个数据在有可能会回滚），这时，另外一个事务也访问这个数据，然后使用了这个数据。

不可重复读 (Non-repeatable read)：在一个事务内，前后两次读到的数据是不一样。在 T1 事务两次读取同一数据之间，T2 事务对该数据进行了修改，就会发生 T1 事务中的两次数据读取不一样的结果。相反， 可重复读：在同一事务中多次读取数据时，能够保证所读数据一样，也就是后续读取不能读到另一事务已提交的更新数据。

幻读 (Phantom Read)：指当事务不是独立执行时发生的一种现象，例如：T1 事务对表中的 “全部数据行” 进行了修改，同时 T2 事务向表中插入了一行 “新数据”，操作 T1 事务的用户发现表中还存在没有修改的数据行，就好象发生了幻觉一 样。一般解决幻读的方法是增加范围锁 RangeS，锁定检锁范围为只读，这样就避免了幻读。

不可重复读和幻读的异同

• 两者都表现为两次读取的结果不一致
• 不可重复读是由于另一个事务对数据的更改所造成的
• 幻读是由于另一个事务插入或删除引起的
• 对于不可重复读，只需要锁住满足条件的记录
• 对于幻读，要锁住满足条件及其相近的记录
• 不可重复读表达的是：记录（一行或多行）的值在同一次事务中出现两个不同的结果
• 幻读表达的是：同一事务中查询两次得到两个不同的结果集
• 不可重复读侧重表达 读 - 读
• 幻读则是说 读 - 写，用写来证实读的是鬼影

关于幻读

这里给出 MySQL 在 Repeatable Read 隔离界别下幻读的比较形象的场景：

假设 users 表中 id 为主键

• T1 的时间点事务 1 检测表中没有 id 为 1 的记录

• T2 时间点事务 2 插入 id 为 1 的记录并提交事务

• T3 时间点事务1 尝试插入 id 为 1 的数据时提示主键冲突

• T4 时间点再去检查表中还是没有 id 为 1 的记录（由于 Repeatable Read 隔离级别，事务 2 的插入提交事务 1 读取不到）

MVCC

MVCC 多版本并发控制（Multiversion Concurrency Control）。

每一条记录都有一些隐藏字段，其中 trx_id（事务 id）和 roll_pointer（回滚指针）字段就和 MVCC 密切相关

版本链
每次对数据修改都会使 roll_pointer 指向生成 undo 日志，即形成了数据修改的 版本链，版本链的头节点就是当前数据的最新值。

Read View
对于 RC、RR 隔离级别来说，事务启动后在不同的时机会生成 Read View，用于判断当前记录是否在事务中可见。Read View 包含创建时刻所有活跃的 trx_id 的集合 m_ids。当判断数据是否在当前事务中显示时，需要从头到尾遍历版本链，依次取得数据的历史记录判断，直到取到符合条件的历史版本，如果所有的历史记录都不满足则忽略此条数据。

• 当前版本数据记录的 trx_id 如果小于 m_ids 中最小的 trx_id，说明当前版本数据是在当前事务 Read View 生成之前生成的，所以对当前事务可见。
• 当前版本数据记录的 trx_id 如果大于 m_ids 中最大的 trx_id，说明当前版本数据是在当前事务 Read View 生成之后生成的，所以对当前事务不可见。
• 当前版本数据记录的 trx_id 如果在 m_ids 中，说明当前版本数据在当前事务 Read View 生成之前还未提交，所以对当前事务不可见。
• 当前版本数据记录的 trx_id 如果不在 m_ids 中，说明当前版本数据是在当前事务 Read View 生成之前已提交，所以对当前事务可见。

RC 隔离级别在每次读取数据前都会生成 Read View，RR 隔离级别在第一次读取数据时生成 Read View，运用以上可见规则就很容易推断出这两种隔离级别的隔离能力了。

另外，undo 日志会在系统判断没有比它更早的 Read View 存在时就会被删除。所以当系统中存在大量长事务的时候，会导致 undo 日志不能被及时清理而占用大量的存储空间。

MySQL 隔离级别

MySQL 事务隔离级别设置

InnoDB 默认是可重复读的（REPEATABLE READ）

修改全局默认的事务级别，在 my.inf 文件的 [mysqld] 节里类似如下设置该选项（不推荐）

1

transaction-isolation = {READ-UNCOMMITTED | READ-COMMITTED | REPEATABLE-READ | SERIALIZABLE}

改变单个会话或者所有新进连接的隔离级别（推荐使用）

1

SET [SESSION | GLOBAL] TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE}

查询全局和会话事务隔离级别方法

1
2
3
4

#查询全局的事务隔离级别
SELECT @@global.tx_isolation;
#查询当前会话的事务级别
SELECT @@session.tx_isolation;

如果我们想要类似以下这样的 URL 时就需要把 Gitea 容器的和主机共享 22 端口
git@git.example.com:username/project.git

下面总结一下使用 Docker 安装 Gitea 共享主机 22 端口的主要步骤，Gogs 应该是同理。

创建 git 用户

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Create git user
adduser git

# Make sure user has UID and GID 1000
usermod -u 1000 -g 1000 git

# Create docker group
groupadd docker

# Add git user to docker group
usermod -aG docker git

# Create the gitea data directory

mkdir -p /home/git/gitea/data

安装 Gitea

1
2
3
4

docker run -d --name=gitea -p 10022:22 -p 10080:3000 -v /home/git/gitea/data:/data --restart=always gitea/gitea:latest

# Create a symlink between the container authorized_keys and the host git user authorized_keys
ln -s /home/git/gitea/data/git/.ssh /home/git/

生成 SSH key

1
2
3
4
5

sudo -u git ssh-keygen -t rsa -b 4096 -C "Gitea Host Key"

echo "no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty $(cat /home/git/.ssh/id_rsa.pub)" >> /home/git/.ssh/authorized_keys

chmod 600 /home/git/.ssh/authorized_keys

配置 SSH passthrough

配置 passthrough 连接到 Gitea 容器的 SSH 映射端口 10022

1
2
3
4
5
6
7
8
9

mkdir -p /app/gitea/

cat >/app/gitea/gitea <<'END'
#!/bin/sh
ssh -p 10022 -o StrictHostKeyChecking=no git@127.0.0.1 \
"SSH_ORIGINAL_COMMAND=\"$SSH_ORIGINAL_COMMAND\" $0 $@"
END

chmod +x /app/gitea/gitea

Caddy 反向代理配置

这里使用 Caddy 反向代理配置域名，Caddyfile 配置信息如下：

1
2
3
4
5
6

git.example.com {
    encode zstd gzip

    reverse_proxy localhost:10080
    header / Strict-Transport-Security "max-age=31536000;"
}

配置完域名之后，输入域名进行安装，现在就可以修改 【SSH 服务域名】 为 git.example.com，【Gitea 基本 URL】 为 https://git.example.com/，也可以后通过 /home/git/gogs/data/gogs/conf/app.ini 配置文件修改相关配置。

注意事项

• 由于 docker 启动容器的默认 uid 和 gid 是 1000，所以 git 用户的 uid、gid 必须为 1000，如果 git 用户的 uid 和 gid 不是 1000（比如：1002），尝试通过 docker run --user 1002:1002、 docker run -e "PUID=1002" -e "PGID=1002" 等方式启动 docker 容器都不管用。

• 保证 git 用户下的所有文件都属于 git 用户和 git 组

1
2
3
4
5
6
7

[git]$ ls -la /home/git/gitea/data
total 20
drwxrwxr-x  5 git git 4096 Jan  5 14:14 .
drwxrwxr-x  3 git git 4096 Jan  5 13:56 ..
drwxr-xr-x  5 git git 4096 Jan  5 14:20 git
drwxr-xr-x 10 git git 4096 Jan  5 14:40 gitea
drwx------  2 git git 4096 Jan  5 14:14 ssh

参考文章

• Gogs 与主机共享 22 端口
• docker-gitea

以 Long.valueOf() 为例，假如需要把一个字符串转换为long，如果转换失败则设置默认值为 -1，一般会作如下处理：

1
2
3
4
5
6
7
8
9
10

String param = "10s";

long result;
try {
    result = Long.parseLong(param);
} catch (Exception e) {
    // 捕获异常处理

    result = -1L;
}

如果使用简化工具：

1
2
3

Long result = Try.of(() -> Long.valueOf(param)).trap(e -> {
    // 自行异常处理
}).get(-1L);

或者：

1

Long result = Try.<String, Long>of(Long::valueOf).trap(Throwable::printStackTrace).apply(param).get(-1L);

如果不需要异常处理：

1
2

Long result = Try.of(() -> Long.valueOf(param)).get(-1L);
// Long result = Try.<String, Long>of(Long::valueOf).apply(param).get(-1L);

如果处理没有返回值的代码，如下：

1
2
3
4
5

ArrayList<String> list = new ArrayList<>();

Try.<String>of(v -> list.add(10, v))
        .trap(e -> System.out.println(e.getMessage()))
        .accept("test");

其它情况的简单使用示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public static void main(String[] args) {
    // 有返回值，无入参
    String param = "s";
    Long result = Try.of(() -> Long.valueOf(param)).get(0L);
    System.out.println("Long.valueOf 1: " + result);

    result = Try.of(() -> Long.valueOf(param)).get();
    System.out.println("Long.valueOf 2: " + result);

    // 有返回值，有入参
    result = Try.<String, Long>of(s -> Long.valueOf(s))
            .apply(param)
            .trap((e) -> System.out.println("Long.valueOf exception: " + e.getMessage()))
            .andFinally(() -> System.out.println("Long.valueOf finally run code."))
            .finallyTrap((e) -> System.out.println("Long.valueOf finally exception: " + e.getMessage()))
            .get();
    System.out.println("Long.valueOf 3: " + result);

    ArrayList<String> list = null;

    // 无返回值，无入参
    Try.of(() -> Thread.sleep(-1L))
            .andFinally(() -> list.clear())
            // .andFinally(list::clear) //https://stackoverflow.com/questions/37413106/java-lang-nullpointerexception-is-thrown-using-a-method-reference-but-not-a-lamb
            .run();

    // 无返回值，有入参
    Try.<String>of(v -> list.add(0, v)).accept("test");
}

小工具的实现链接

想要了解 https 流程，CA 的相关知识，加密方式（对称加密、非对称加密），以及哈希计算（例如：MD5、sha256）等技术必须得掌握，这里先不做介绍，后续有时间再进行归纳总结。

https 是在 http 的基础上加入了 SSL 协议，SSL 依靠证书来验证服务器的身份，并为浏览器和服务器之间的通信进行加密。

HTTPS 的验证流程

1. 客户端发起 https 请求
2. 服务端返回数字证书文件（X.509 格式）
3. 客户端验证数字证书，并且提取服务端公钥
4. 如果客户端验证数字证书通过，则随机生成一个对称加密的 key，并使用服务器公钥对 key 加密
5. 客户端发送加密后的 key 到服务端
6. 服务端使用私钥解密拿到 key
7. 客户端与服务端使用该 key 对称加解密通讯信息

客户端验证数字证书

1. 浏览器安装后会自带一些权威 CA 公钥
2. 使用相匹配的 CA 公钥对数字证书中的数字签名解密，如果能够解密则得到数字证书的摘要，由此证明数字证书是可信的
3. 根据数字证书中的散列算法对网站信息进行哈希运算，将得到的结果与上一步得到的摘要对比，如果两者一致，就证明证书未被修改过

数字证书的签发过程

配置文件的优先级从高到低为：pom.xml、用户配置 settings.xml、全局系统 settings.xml。如果这些文件同时存在，在应用配置时，会合并它们的内容，如果有重复的配置，优先级高的配置会覆盖优先级低的。

现抽空把 settings.xml 相关配置属性总结一下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
    <!-- 构建系统本地仓库的路径。其默认值：~/.m2/repository -->
    <!-- <localRepository>${user.home}/.m2/repository</localRepository> -->

    <!-- 是否需要和用户交互以获得输入。默认为 true -->
    <!-- <interactiveMode>true</interactiveMode> -->

    <!-- 是否需要使用 ~/.m2/plugin-registry.xml 文件来管理插件版本。默认为 false -->
    <!-- <usePluginRegistry>false</usePluginRegistry> -->

    <!-- 是否需要在离线模式下运行，默认为 false。当由于网络设置原因或者安全因素，构建服务器不能连接远程仓库的时候，该配置就十分有用 -->
    <!-- <offline>false</offline> -->

    <!-- 当插件的 groupId 没有显式提供时，供搜寻插件 groupId 的列表。使用某个插件，如果没有指定 groupId 的时候，maven 就会使用该列表。
        默认情况下该列表包含了 org.apache.maven.plugins 和 org.codehaus.mojo -->
    <!-- <pluginGroups> -->
        <!-- plugin 的 groupId -->
        <!-- <pluginGroup>org.codehaus.mojo</pluginGroup> -->
    <!-- </pluginGroups> -->

    <!-- 配置服务端的一些设置。如安全证书之类的信息应该配置在 settings.xml 文件中，避免配置在 pom.xml 中 -->
    <!-- <servers> -->
        <!-- <server> -->
            <!-- 这是 server 的 id（注意不是用户登陆的 id），该 id 与 distributionManagement 中 repository 元素的 id 相匹配 -->
            <!-- <id>server001</id> -->
            <!-- 鉴权用户名 -->
            <!-- <username>my_login</username> -->
            <!-- 鉴权密码 -->
            <!-- <password>my_password</password> -->
            <!-- 鉴权时使用的私钥位置。默认是 ${user.home}/.ssh/id_dsa -->
            <!-- <privateKey>${usr.home}/.ssh/id_dsa</privateKey> -->
            <!-- 鉴权时使用的私钥密码 -->
            <!-- <passphrase>some_passphrase</passphrase> -->
            <!-- 文件被创建时的权限。如果在部署的时候会创建一个仓库文件或者目录，这时候就可以使用该权限。其对应了 unix 文件系统的权限，如：664、775 -->
            <!-- <filePermissions>664</filePermissions> -->
            <!-- 目录被创建时的权限 -->
            <!-- <directoryPermissions>775</directoryPermissions> -->
        <!-- </server> -->
    <!-- </servers> -->

    <!-- 下载镜像列表 -->
    <mirrors>
        <!-- 设置多个镜像只会识别第一个镜像下载 jar 包-->
        <mirror>
            <!-- 该镜像的唯一标识符。id 用来区分不同的 mirror 元素 -->
            <id>aliyunmaven</id>
            <!-- 被镜像的服务器的 id。如果我们要设置了一个 maven 中央仓库（http://repo.maven.apache.org/maven2/）的镜像，就需要将该元素设置成 central。
                可以使用 * 表示任意远程库。例如：external:* 表示任何不在 localhost 和文件系统中的远程库，r1,r2 表示 r1 库或者 r2 库，*,!r1 表示除了 r1 库之外的任何远程库 -->
            <mirrorOf>*</mirrorOf>
            <!-- 镜像名称 -->
            <name>阿里云公共仓库</name>
            <!-- 镜像的 URL -->
            <url>https://maven.aliyun.com/repository/public</url>
        </mirror>
    </mirrors>

    <!-- 用来配置不同的代理 -->
    <proxies>
        <proxy>
            <!-- 代理的唯一定义符，用来区分不同的代理元素 -->
            <id>myproxy</id>
            <!-- 是否激活。当我们声明了一组代理，而某个时候只需要激活一个代理的时候 -->
            <active>false</active>
            <!-- 代理的协议 -->
            <protocol>http</protocol>
            <!-- 代理的主机名 -->
            <host>proxy.somewhere.com</host>
            <!-- 代理的端口 -->
            <port>8080</port>
            <!-- 代理的用户名，用户名和密码表示代理服务器认证的登录名和密码 -->
            <username>proxyuser</username>
            <!-- 代理的密码 -->
            <password>somepassword</password>
            <!-- 不该被代理的主机名列表。该列表的分隔符由代理服务器指定；例子中使用了竖线分隔符，逗号分隔也很常见 -->
            <nonProxyHosts>*.google.com|ibiblio.org</nonProxyHosts>
        </proxy>
    </proxies>

    <!-- 根据环境参数来调整构建配置的列表。对应 pom.xml 中 profile 元素（只包含 id、activation、repositories、pluginRepositories 和 properties 元素）
        如果一个 settings.xml 中的 profile 被激活，它的值会覆盖任何定义在 pom.xml 中带有相同 id 的 profile -->
    <profiles>
        <profile>
            <!-- profile 的唯一标识 -->
            <id>test</id>
            <!-- 自动触发 profile 的条件逻辑。也可通过 activeProfile 元素以及使用 -P 标记激活（如：mvn clean install -P test）
                在 maven 工程的 pom.xml 所在目录下执行 mvn help:active-profiles 命令可以查看生效的 profile -->
            <activation>
                <!-- 默认是否激活 -->
                <activeByDefault>false</activeByDefault>
                <!-- 当匹配的 jdk 被检测到，profile 被激活。例如：1.4 激活 JDK1.4、1.4.0_2，而 !1.4 激活所有版本不是以 1.4 开头的 JDK -->
                <jdk>1.8</jdk>
                <!-- 当匹配的操作系统属性被检测到，profile 被激活。os 元素可以定义一些操作系统相关的属性 -->
                <os>
                    <!-- 激活 profile的 操作系统的名字 -->
                    <name>Windows XP</name>
                    <!--激活 profile 的操作系统所属家族。如：windows -->
                    <family>Windows</family>
                    <!--激活 profile 的操作系统体系结构 -->
                    <arch>x86</arch>
                    <!--激活p rofile 的操作系统版本 -->
                    <version>5.1.2600</version>
                </os>
                <!-- 如果 maven 检测到某一个属性（其值可以在 pom.xml 中通过 ${name} 引用），其拥有对应的 name=值，Profile 就会被激活。如果值字段是空的，
                    那么存在属性名称字段就会激活 profile，否则按区分大小写方式匹配属性值字段 -->
                <property>
                    <!-- 激活 profile 的属性的名称 -->
                    <name>mavenVersion</name>
                    <!-- 激活 profile 的属性的值 -->
                    <value>2.0.3</value>
                </property>
                <!-- 通过检测该文件的存在或不存在来激活 profile-->
                <file>
                    <!-- 如果指定的文件存在，则激活 profile -->
                    <exists>${basedir}/file2.properties</exists>
                    <!-- 如果指定的文件不存在，则激活 profile -->
                    <missing>${basedir}/file1.properties</missing>
                </file>
            </activation>
            <!-- 对应 profile 的扩展属性列表。maven 属性和 ant 中的属性一样，可以用来存放一些值。这些值可以在 pom.xml 中的任何地方使用标记 ${X} 来使用，这里 X 是指属性的名称。
                属性有五种不同的形式，并且都能在 settings.xml 文件中访问：
                1. env.X：在一个变量前加上 "env." 的前缀，会返回一个 shell 环境变量。例如："env.PATH" 指代了 $path 环境变量（在 Windows 上是 %PATH%）
                2. project.x：指代了 pom.xml 中对应的元素值。例如：<project><version>1.0</version></project> 通过 ${project.version} 获得 version 的值
                3. settings.x：指代了 settings.xml 中对应元素的值。例如：<settings><offline>false</offline></settings> 通过 ${settings.offline} 获得 offline 的值
                4. Java System Properties：所有可通过 java.lang.System.getProperties() 访问的属性都能在 pom.xml 中使用该形式访问，例如：${java.home}
                5. x：在 <properties/> 元素中，或者外部文件中设置，以 ${someVar} 的形式使用
            -->
            <properties>
                <!-- 如果该 profile 被激活，则可以在 pom.xml 中使用 ${user.install} -->
                <user.install>${user.home}/our-project</user.install>
            </properties>
            <!-- 远程仓库列表。它是 maven 用来填充构建系统本地仓库所使用的一组远程仓库 -->
            <repositories>
                <!--包含需要连接到远程仓库的信息 -->
                <repository>
                    <!-- 远程仓库唯一标识 -->
                    <id>codehausSnapshots</id>
                    <!-- 远程仓库名称 -->
                    <name>Codehaus Snapshots</name>
                    <!-- 如何处理远程仓库里 releases 的下载 -->
                    <releases>
                        <!-- 是否开启 -->
                        <enabled>false</enabled>
                        <!-- 该元素指定更新发生的频率。maven 会比较本地 pom.xml 和远程 pom.xml 的时间戳。
                            这里的选项是：always（一直），daily（默认，每日），interval：X（这里 X 是以分钟为单位的时间间隔），或者 never（从不）。 -->
                        <updatePolicy>always</updatePolicy>
                        <!-- 当 maven 验证构件校验文件失败时该怎么做：ignore（忽略），fail（失败），或者 warn（警告）-->
                        <checksumPolicy>warn</checksumPolicy>
                    </releases>
                    <!-- 如何处理远程仓库里快照版本的下载。有了 releases 和 snapshots 这两组配置，pom.xml 就可以在每个单独的仓库中，为每种类型的构件采取不同的策略。
                        例如：可能有人会决定只为开发目的开启对快照版本下载的支持 -->
                    <snapshots>
                        <enabled/>
                        <updatePolicy/>
                        <checksumPolicy/>
                    </snapshots>
                    <!-- 远程仓库 URL -->
                    <url>http://snapshots.maven.codehaus.org/maven2</url>
                    <!-- 用于定位和排序构件的仓库布局类型。可以是 default（默认）或者 legacy（遗留）-->
                    <layout>default</layout>
                </repository>
            </repositories>
            <!-- 插件的远程仓库列表。和 repositories 类似，repositories 管理 jar 包依赖的仓库，pluginRepositories 则是管理插件的仓库 -->
            <pluginRepositories>
                <!-- 每个 pluginRepository 元素指定一个 maven 可以用来寻找新插件的远程地址 -->
                <pluginRepository>
                    <id/>
                    <name/>
                    <releases>
                        <enabled/>
                        <updatePolicy/>
                        <checksumPolicy/>
                    </releases>
                    <snapshots>
                        <enabled/>
                        <updatePolicy/>
                        <checksumPolicy/>
                    </snapshots>
                    <url/>
                    <layout/>
                </pluginRepository>
            </pluginRepositories>
        </profile>
    </profiles>

    <!-- 手动激活 profiles 的列表 -->
    <!-- <activeProfiles> -->
        <!-- 要激活的 profile id。例如：env-test，则在 pom.xml 或 settings.xml 中对应 id 的 profile 会被激活。如果运行过程中找不到对应的 profile 则忽略配置 -->
        <!-- <activeProfile>env-test</activeProfile> -->
  <!-- </activeProfiles> -->
</settings>

参考资料

• maven 官方文档之 settings

动态代理是 Java 语言中非常经典的一种设计模式，也是所有设计模式中最难理解的一种。本文将通过一个简单的例子模拟 JDK 动态代理实现，让你彻底明白动态代理设计模式的本质。

什么是代理

从字面意思来看，代理比较好理解，无非就是代为处理的意思。举个例子，你在上大学的时候，总是喜欢逃课。因此，你拜托你的同学帮你答到，而自己却窝在宿舍玩游戏… 你的这个同学恰好就充当了代理的作用，代替你去上课。

是的，你没有看错，代理就是这么简单！

理解了代理的意思，你脑海中恐怕还有两个巨大的疑问：

• 怎么实现代理模式
• 代理模式有什么实际用途

要理解这两个问题，看一个简单的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public interface Flyable {
    void fly();
}

public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("Bird is flying...");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

很简单的一个例子，用一个随机睡眠时间模拟小鸟在空中的飞行时间。接下来问题来了，如果我要知道小鸟在天空中飞行了多久，怎么办？

有人说，很简单，在 Bird->fly () 方法的开头记录起始时间，在方法结束记录完成时间，两个时间相减就得到了飞行时间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Override
public void fly() {
    long start = System.currentTimeMillis();
    System.out.println("Bird is flying...");

    try {
      Thread.sleep(new Random().nextInt(1000));
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    long end = System.currentTimeMillis();
    System.out.println("Fly time = " + (end - start));
}

的确，这个方法没有任何问题，接下来加大问题的难度。如果 Bird 这个类来自于某个 SDK（或者说 Jar 包）提供，你无法改动源码，怎么办？

一定会有人说，我可以在调用的地方这样写：

1
2
3
4
5
6
7
8
9

public static void main(String[] args) {
    Bird bird = new Bird();
    long start = System.currentTimeMillis();

  bird.fly();

  long end = System.currentTimeMillis();
    System.out.println("Fly time = " + (end - start));
}

这个方案看起来似乎没有问题，但其实你忽略了准备这些方法所需要的时间，执行一个方法，需要开辟栈内存、压栈、出栈等操作，这部分时间也是不可以忽略的。因此，这个解决方案不可行。那么，还有什么方法可以做到呢？

使用继承，继承是最直观的解决方案，相信你已经想到了，至少我最开始想到的解决方案就是继承。 为此，我们重新创建一个类 Bird2，在 Bird2 中我们只做一件事情，就是调用父类的 fly 方法，在前后记录时间，并打印时间差：

1
2
3
4
5
6
7
8
9
10
11
12

public class Bird2 extends Bird {

    @Override
    public void fly() {
        long start = System.currentTimeMillis();

        super.fly();

        long end = System.currentTimeMillis();
        System.out.println("Fly time = " + (end - start));
    }
}

这是一种解决方案，还有一种解决方案叫做：聚合，其实也是比较容易想到的。 我们再次创建新类 Bird3，在 Bird3 的构造方法中传入 Bird 实例。同时，让 Bird3 也实现 Flyable 接口，并在 fly方法中调用传入的 Bird 实例的 fly 方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Bird3 implements Flyable {
    private Bird bird;

    public Bird3(Bird bird) {
        this.bird = bird;
    }

    @Override
    public void fly() {
        long start = System.currentTimeMillis();

        bird.fly();

        long end = System.currentTimeMillis();
        System.out.println("Fly time = " + (end - start));
    }
}

为了记录 Bird->fly () 方法的执行时间，我们在前后添加了记录时间的代码。同样地，通过这种方法我们也可以获得小鸟的飞行时间。那么，这两种方法孰优孰劣呢？咋一看，不好评判！

继续深入思考，用问题推导来解答这个问题：

问题一：如果我还需要在 fly 方法前后打印日志，记录飞行开始和飞行结束，怎么办？ 有人说，很简单！继承 Bird2 并在在前后添加打印语句即可。那么，问题来了，请看问题二。

问题二：如果我需要调换执行顺序，先打印日志，再获取飞行时间，怎么办？ 有人说，再新建一个类 Bird4 继承 Bird，打印日志。再新建一个类 Bird5 继承 Bird4，获取方法执行时间。

问题显而易见：使用继承将导致类无限制扩展，同时灵活性也无法获得保障。那么，使用聚合是否可以避免这个问题呢？ 答案是：可以！但我们的类需要稍微改造一下。修改 Bird3 类，将聚合对象 Bird 类型修改为 Flyable

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Bird3 implements Flyable {
    private Flyable flyable;

    public Bird3(Flyable flyable) {
        this.flyable = flyable;
    }

    @Override
    public void fly() {
        long start = System.currentTimeMillis();

        flyable.fly();

        long end = System.currentTimeMillis();
        System.out.println("Fly time = " + (end - start));
    }
}

为了让你看的更清楚，我将 Bird3 更名为 BirdTimeProxy，即用于获取方法执行时间的代理的意思。同时我们新建 BirdLogProxy 代理类用于打印日志：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class BirdLogProxy implements Flyable {
    private Flyable flyable;

    public BirdLogProxy(Flyable flyable) {
        this.flyable = flyable;
    }

    @Override
    public void fly() {
        System.out.println("Bird fly start...");

        flyable.fly();

        System.out.println("Bird fly end...");
    }
}

接下来神奇的事情发生了，如果我们需要先记录日志，再获取飞行时间，可以在调用的地方这么做：

1
2
3
4
5
6
7

public static void main(String[] args) {
    Bird bird = new Bird();
    BirdLogProxy p1 = new BirdLogProxy(bird);
    BirdTimeProxy p2 = new BirdTimeProxy(p1);

    p2.fly();
}

反过来，可以这么做：

1
2
3
4
5
6
7

public static void main(String[] args) {
    Bird bird = new Bird();
    BirdTimeProxy p2 = new BirdTimeProxy(bird);
    BirdLogProxy p1 = new BirdLogProxy(p2);

    p1.fly();
}

看到这里，有同学可能会有疑问了。虽然现象看起来，聚合可以灵活调换执行顺序。可是，为什么聚合可以做到，而继承不行呢。我们用一张图来解释一下：

静态代理

接下来，观察上面的类 BirdTimeProxy，在它的 fly 方法中我们直接调用了 flyable->fly () 方法。换而言之，BirdTimeProxy 其实代理了传入的 Flyable 对象，这就是典型的静态代理实现。

从表面上看，静态代理已经完美解决了我们的问题。可是，试想一下，如果我们需要计算 SDK 中 100 个方法的运行时间，同样的代码至少需要重复 100 次，并且创建至少 100 个代理类。往小了说，如果 Bird 类有多个方法，我们需要知道其他方法的运行时间，同样的代码也至少需要重复多次。因此，静态代理至少有以下两个局限性问题：

• 如果同时代理多个类，依然会导致类无限制扩展
• 如果类中有多个方法，同样的逻辑需要反复实现

那么，我们是否可以使用同一个代理类来代理任意对象呢？我们以获取方法运行时间为例，是否可以使用同一个类（例如：TimeProxy）来计算任意对象的任一方法的执行时间呢？甚至再大胆一点，代理的逻辑也可以自己指定。比如，获取方法的执行时间，打印日志，这类逻辑都可以自己指定。这就是本文重点探讨的问题，也是最难理解的部分：动态代理。

动态代理

继续回到上面这个问题：是否可以使用同一个类（例如：TimeProxy）来计算任意对象的任一方法的执行时间呢。

这个部分需要一定的抽象思维，我想，你脑海中的第一个解决方案应该是使用反射。反射是用于获取已创建实例的方法或者属性，并对其进行调用或者赋值。很明显，在这里，反射解决不了问题。但是，再大胆一点，如果我们可以动态生成 TimeProxy 这个类，并且动态编译。然后，再通过反射创建对象并加载到内存中，不就实现了对任意对象进行代理了吗？为了防止你依然一头雾水，我们用一张图来描述接下来要做什么：

动态生成 Java 源文件并且排版是一个非常繁琐的工作，为了简化操作，我们使用 JavaPoet 这个第三方库帮我们生成 TimeProxy 的源码。希望 JavaPoet 不要成为你的负担，不理解 JavaPoet 没有关系，你只要把它当成一个 Java 源码生成工具使用即可。

PS：你记住，任何工具库的使用都不会太难，它是为了简化某些操作而出现的，目标是简化而不是繁琐。因此，只要你适应它的规则就轻车熟路了。

第一步：生成 TimeProxy 源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public class Proxy {

    public static Object newProxyInstance() throws IOException {
        TypeSpec.Builder typeSpecBuilder = TypeSpec.classBuilder("TimeProxy").addSuperinterface(Flyable.class);

        FieldSpec fieldSpec = FieldSpec.builder(Flyable.class, "flyable", Modifier.PRIVATE).build();
        typeSpecBuilder.addField(fieldSpec);

        MethodSpec constructorMethodSpec = MethodSpec.constructorBuilder()
                .addModifiers(Modifier.PUBLIC)
                .addParameter(Flyable.class, "flyable")
                .addStatement("this.flyable = flyable")
                .build();
        typeSpecBuilder.addMethod(constructorMethodSpec);

        Method[] methods = Flyable.class.getDeclaredMethods();
        for (Method method : methods) {
            MethodSpec methodSpec = MethodSpec.methodBuilder(method.getName())
                    .addModifiers(Modifier.PUBLIC)
                    .addAnnotation(Override.class)
                    .returns(method.getReturnType())
                    .addStatement("long start = $T.currentTimeMillis()", System.class)
                    .addCode("\n")
                    .addStatement("this.flyable." + method.getName() + "()")
                    .addCode("\n")
                    .addStatement("long end = $T.currentTimeMillis()", System.class)
                    .addStatement("$T.out.println(\"Fly Time =\" + (end - start))", System.class)
                    .build();
            typeSpecBuilder.addMethod(methodSpec);
        }

        JavaFile javaFile = JavaFile.builder("com.youngfeng.proxy", typeSpecBuilder.build()).build();
        // 为了看的更清楚，我将源码文件生成到桌面
        javaFile.writeTo(new File("/Users/ouyangfeng/Desktop/"));

        return null;
    }
}

在 main 方法中调用 Proxy.newProxyInstance ()，你将看到桌面已经生成了 TimeProxy.java 文件，生成的内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package com.youngfeng.proxy;

import java.lang.Override;
import java.lang.System;

class TimeProxy implements Flyable {
  private Flyable flyable;

  public TimeProxy(Flyable flyable) {
    this.flyable = flyable;
  }

  @Override
  public void fly() {
    long start = System.currentTimeMillis();

    this.flyable.fly();

    long end = System.currentTimeMillis();
    System.out.println("Fly Time =" + (end - start));
  }
}

第二步：编译 TimeProxy 源码

编译 TimeProxy 源码我们直接使用 JDK 提供的编译工具即可，为了使你看起来更清晰，我使用一个新的辅助类来完成编译操作：

1
2
3
4
5
6
7
8
9
10
11

public class JavaCompiler {

    public static void compile(File javaFile) throws IOException {
        javax.tools.JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager fileManager = javaCompiler.getStandardFileManager(null, null, null);
        Iterable iterable = fileManager.getJavaFileObjects(javaFile);
        javax.tools.JavaCompiler.CompilationTask task = javaCompiler.getTask(null, fileManager, null, null, null, iterable);
        task.call();
        fileManager.close();
    }
}

在 Proxy->newProxyInstance () 方法中调用该方法，编译顺利完成：

1
2
3
4
5
6

// 为了看的更清楚，我将源码文件生成到桌面
String sourcePath = "/Users/ouyangfeng/Desktop/";
javaFile.writeTo(new File(sourcePath));

// 编译
JavaCompiler.compile(new File(sourcePath + "/com/youngfeng/proxy/TimeProxy.java"));

第三步：加载到内存中并创建对象

1
2
3
4
5
6
7
8

URL[] urls = new URL[] {new URL("file:/" + sourcePath)};
URLClassLoader classLoader = new URLClassLoader(urls);

Class clazz = classLoader.loadClass("com.youngfeng.proxy.TimeProxy");
Constructor constructor = clazz.getConstructor(Flyable.class);
Flyable flyable = (Flyable) constructor.newInstance(new Bird());

flyable.fly();

通过以上三个步骤，我们至少解决了下面两个问题：

• 不再需要手动创建 TimeProxy
• 可以代理任意实现了 Flyable 接口的类对象，并获取接口方法的执行时间

可是，说好的任意对象呢？

第四步：增加 InvocationHandler 接口

查看 Proxy->newProxyInstance () 的源码，代理类继承的接口我们是写死的，为了增加灵活性，我们将接口类型作为参数传入：

接口的灵活性问题解决了，TimeProxy 的局限性依然存在，它只能用于获取方法的执行时间，而如果要在方法执行前后打印日志则需要重新创建一个代理类，显然这是不妥的！

为了增加控制的灵活性，我们考虑针将代理的处理逻辑也抽离出来（这里的处理就是打印方法的执行时间）。新增 InvocationHandler 接口，用于处理自定义逻辑：

1
2
3

public interface InvocationHandler {
    void invoke(Object proxy, Method method, Object[] args);
}

想象一下，如果客户程序员需要对代理类进行自定义的处理，只要实现该接口，并在 invoke 方法中进行相应的处理即可。这里我们在接口中设置了三个参数（其实也是为了和 JDK 源码保持一致）：

• proxy：这个参数指定动态生成的代理类，这里是 TimeProxy
• method：这个参数表示传入接口中的所有 Method 对象
• args：这个参数对应当前 method 方法中的参数

引入了 InvocationHandler 接口之后，我们的调用顺序应该变成了这样：

1
2
3
4

MyInvocationHandler handler = new MyInvocationHandler();
Flyable proxy = Proxy.newProxyInstance(Flyable.class, handler);

proxy.fly();

方法执行流：proxy.fly() => handler.invoke()

为此，我们需要在 Proxy.newProxyInstance () 方法中做如下改动：

• 在 newProxyInstance 方法中传入 InvocationHandler
• 在生成的代理类中增加成员变量 handler
• 在生成的代理类方法中，调用 invoke 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

public static Object newProxyInstance(Class inf, InvocationHandler handler) throws Exception {
        TypeSpec.Builder typeSpecBuilder = TypeSpec.classBuilder("TimeProxy")
                .addModifiers(Modifier.PUBLIC)
                .addSuperinterface(inf);

        FieldSpec fieldSpec = FieldSpec.builder(InvocationHandler.class, "handler", Modifier.PRIVATE).build();
        typeSpecBuilder.addField(fieldSpec);

        MethodSpec constructorMethodSpec = MethodSpec.constructorBuilder()
                .addModifiers(Modifier.PUBLIC)
                .addParameter(InvocationHandler.class, "handler")
                .addStatement("this.handler = handler")
                .build();

        typeSpecBuilder.addMethod(constructorMethodSpec);

        Method[] methods = inf.getDeclaredMethods();
        for (Method method : methods) {
            MethodSpec methodSpec = MethodSpec.methodBuilder(method.getName())
                    .addModifiers(Modifier.PUBLIC)
                    .addAnnotation(Override.class)
                    .returns(method.getReturnType())
                    .addCode("try {\n")
                    .addStatement("\t$T method = " + inf.getName() + ".class.getMethod(\"" + method.getName() + "\")", Method.class)
                    // 为了简单起见，这里参数直接写死为空
                    .addStatement("\tthis.handler.invoke(this, method, null)")
                    .addCode("} catch(Exception e) {\n")
                    .addCode("\te.printStackTrace();\n")
                    .addCode("}\n")
                    .build();
            typeSpecBuilder.addMethod(methodSpec);
        }

        JavaFile javaFile = JavaFile.builder("com.youngfeng.proxy", typeSpecBuilder.build()).build();
        // 为了看的更清楚，我将源码文件生成到桌面
        String sourcePath = "/Users/ouyangfeng/Desktop/";
        javaFile.writeTo(new File(sourcePath));

        // 编译
        JavaCompiler.compile(new File(sourcePath + "/com/youngfeng/proxy/TimeProxy.java"));

        // 使用反射load到内存
        URL[] urls = new URL[] {new URL("file:" + sourcePath)};
        URLClassLoader classLoader = new URLClassLoader(urls);
        Class clazz = classLoader.loadClass("com.youngfeng.proxy.TimeProxy");
        Constructor constructor = clazz.getConstructor(InvocationHandler.class);
        Object obj = constructor.newInstance(handler);

        return obj;
}

上面的代码你可能看起来比较吃力，我们直接调用该方法，查看最后生成的源码。在 main 方法中测试 newProxyInstance 查看生成的 TimeProxy 源码：

测试代码

1

Proxy.newProxyInstance(Flyable.class, new MyInvocationHandler(new Bird()));

生成的 TimeProxy.java 源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package com.youngfeng.proxy;

import java.lang.Override;
import java.lang.reflect.Method;

public class TimeProxy implements Flyable {
  private InvocationHandler handler;

  public TimeProxy(InvocationHandler handler) {
    this.handler = handler;
  }

  @Override
  public void fly() {
    try {
    Method method = com.youngfeng.proxy.Flyable.class.getMethod("fly");
    this.handler.invoke(this, method, null);
    } catch(Exception e) {
    e.printStackTrace();
    }
  }
}

MyInvocationHandler.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class MyInvocationHandler implements InvocationHandler {
    private Bird bird;

    public MyInvocationHandler(Bird bird) {
        this.bird = bird;
    }

    @Override
    public void invoke(Object proxy, Method method, Object[] args) {
        long start = System.currentTimeMillis();

        try {
            method.invoke(bird, new Object[] {});
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        long end = System.currentTimeMillis();
        System.out.println("Fly time = " + (end - start));
    }
}

至此，整个方法栈的调用栈变成了这样：

看到这里，估计很多同学已经晕了，在静态代理部分，我们在代理类中传入了被代理对象。可是，使用 newProxyInstance 生成动态代理对象的时候，我们居然不再需要传入被代理对象了。我们传入了的实际对象是 InvocationHandler 实现类的实例，这看起来有点像生成了 InvocationHandler 的代理对象，在动态生成的代理类的任意方法中都会间接调用 InvocationHandler->invoke (proxy, method, args) 方法。

其实的确是这样。TimeProxy 真正代理的对象就是 InvocationHandler，不过这里设计的巧妙之处在于，InvocationHandler 是一个接口，真正的实现由用户指定。另外，在每一个方法执行的时候，invoke 方法都会被调用 ，这个时候如果你需要对某个方法进行自定义逻辑处理，可以根据 method 的特征信息进行判断分别处理。

如何使用

上面这段解释是告诉你在执行 Proxy->newProxyInstance 方法的时候真正发生的事情，而在实际使用过程中你完全可以忘掉上面的解释。按照设计者的初衷，我们做如下简单归纳：

• Proxy->newProxyInstance (infs, handler) 用于生成代理对象
• InvocationHandler这个接口主要用于自定义代理逻辑处理
• 为了完成对被代理对象的方法拦截，我们需要在 InvocationHandler 对象中传入被代理对象实例。

查看上面的代码，你可以看到我将 Bird 实例已经传入到了 MyInvocationHandler 中，原因就是第三点。

这样设计有什么好处呢？有人说，我们大费周章，饶了一大圈，最终变成了这个样子，到底图什么呢？

想象一下，到此为止，如果我们还需要对其它任意对象进行代理，是否还需要改动 newProxyInstance 方法的源码，答案是：完全不需要！

只要你在 newProxyInstance 方法中指定代理需要实现的接口，指定用于自定义处理的 InvocationHandler 对象，整个代理的逻辑处理都在你自定义的 InvocationHandler 实现类中进行处理。至此，而我们终于可以从不断地写代理类用于实现自定义逻辑的重复工作中解放出来了，从此需要做什么，交给 InvocationHandler。

事实上，我们之前给自己定下的目标 “使用同一个类来计算任意对象的任一方法的执行时间” 已经实现了。严格来说，是我们超额完成了任务，TimeProxy 不仅可以计算方法执行的时间，也可以打印方法执行日志，这完全取决于你的 InvocationHandler 接口实现。因此，这里取名为 TimeProxy 其实已经不合适了。我们可以修改为和 JDK 命名一致，即 $Proxy0，感兴趣的同学请自行实践。

JDK 实现揭秘

通过上面的这些步骤，我们完成了一个简易的仿 JDK 实现的动态代理逻辑。接下来，我们一起来看一看 JDK 实现的动态代理和我们到底有什么不同。

Proxy.java

InvocationHandler

可以看到，官方版本 Proxy 类提供的方法多一些，而我们主要使用的接口 newProxyInstance 参数也和我们设计的不太一样。这里给大家简单解释一下，每个参数的意义：

• Classloader：类加载器，你可以使用自定义的类加载器，我们的实现版本为了简化，直接在代码中写死了 Classloader。
• Class<?>[]：第二个参数也和我们的实现版本不一致，这个其实很容易理解，我们应该允许我们自己实现的代理类同时实现多个接口。前面设计只传入一个接口，只是为了简化实现，让你专注核心逻辑实现而已。

最后一个参数就不用说了，和我们实现的版本完全是一样的。

仔细观察官方版本的 InvocationHandler，它和我们自己的实现的版本也有一个细微的差别：官方版本 invoke 方法有返回值，而我们的版本中是没有返回值的。那么，返回值到底有什么作用呢？直接来看官方文档：

核心思想：这里的返回值类型必须和传入接口的返回值类型一致，或者与其封装对象的类型一致。

遗憾的是，这里并没有说明返回值的用途，其实这里稍微发挥一下想象力就知道了。在我们的版本实现中，Flyable 接口的所有方法都是没有返回值的，问题是，如果有返回值呢？是的，你没有猜错，这里的 invoke 方法对应的就是传入接口中方法的返回值。

答疑解惑

invoke 方法的第一个参数 proxy 到底有什么作用？

这个问题其实也好理解，如果你的接口中有方法需要返回自身，如果在 invoke 中没有传入这个参数，将导致实例无法正常返回。在这种场景中，proxy 的用途就表现出来了。简单来说，这其实就是最近非常火的链式编程的一种应用实现。

动态代理到底有什么用？

学习任何一门技术，一定要问一问自己，这到底有什么用。其实，在这篇文章的讲解过程中，我们已经说出了它的主要用途。你发现没，使用动态代理我们居然可以在不改变源码的情况下，直接在方法中插入自定义逻辑。这有点不太符合我们的一条线走到底的编程逻辑，这种编程模型有一个专业名称叫 AOP。所谓的 AOP，就像刀一样，抓住时机，趁机插入。

基于这样一种动态特性，我们可以用它做很多事情，例如：

• 事务提交或回退（Web 开发中很常见）
• 权限管理
• 自定义缓存逻辑处理
• SDK Bug 修复 …

总结

到此为止，关于动态代理的所有讲解已经结束了，原谅我使用了一个诱导性的标题 “骗” 你进来阅读这篇文章。如果你不是一个久经沙场的 “老司机”，10 分钟完全看懂动态代理设计模式还是有一定难度的。但即使没有看懂也没关系，如果你在第一次阅读完这篇文章后依然一头雾水，就不妨再仔细阅读一次。在阅读的过程中，一定要跟着文章思路去敲代码。反反复复，一定会看懂的。我在刚刚学习动态代理设计模式的时候就反复看了不下 5 遍，并且亲自敲代码实践了多次。

为了让你少走弯路，我认为看懂这篇文章，你至少需要学习以下知识点：

• 至少已经理解了面向对象语言的多态特性
• 了解简单的反射用法
• 会简单使用 JavaPoet 生成 Java 源码

19 年最开心的事儿就是当了爸爸，真心的感谢媳妇艰辛付出，感激上天给我们最好的礼物。最不幸的事是父亲得了一场大病，家人辛苦奔波不说父亲也是受尽了病痛的折磨，医院真是最不愿意去的地方。有时候天真的想，如果能让家人健健康康无病无痛，付出多少都会有人愿意吧！

在北京已经整整 8 年了，虽不说劳苦奔波，但每天也很疲惫，一直想着回西安去好好安顿自己的家，尤其是面对不管奋斗多久也在这个城市安不了一个家的现实的时候。但有孩子之后经济压力徒增，回去之后恐怕入不敷出，一年一年的过的很快，那就再在北京待一年再看情况吧！为了能够不焦虑的回西安 20 年得让自己有点儿改观了。

19 年最后一天也快下班了，20 年继续加油吧！

Rust 字符串有两种形式：str 和 String，str 是内置的原始数据类型，通常是以借用的形式（&str 字符串 slice）使用，而 String 是标准库提供的一种结构体，内部存储一个 u8 类型的 Vec：

1
2
3

pub struct String {
    vec: Vec<u8>,
}

str

1
2
3

let s = "hello world!";

// let s: &'static str = "hello world!";

s 变量是一个 &str 类型，不可变的字符串，也可称为字面量，文本被直接储存在程序的二进制文件中，拥有固态生命周期（'static），是 let s: &'static str = "hello world!"; 的简写定义方式。

String

1
2
3
4
5
6
7
8

let mut s1 = String::new();
// let mut s1 = String::from("hello world!");
s1.push_str("hello world!");
s1.push_str(" welcome.");

println!("{}", s1);
// Output:
// hello world! welcome.

String 是可变的、有所有权的、堆上分配的 UTF-8 的字节缓冲区。

相互转换

• &str -> String

1
2
3
4
5

let s = "hello world!"; // variable s: &str

let s1 = String::from(s); // variable s1: String
let s1 = s.to_string();
let s1 = s.to_owned();

• String -> &str

1
2
3

let s = String::from("hello world!"); // variable s: String
let s1 = s.as_str(); // variable s1: &str
let s1 = &s[..]; // 相当于：&s[0..s.len()];

&String 可以当做是 &str，例如：

1
2
3
4
5
6
7

fn main() {
    let s = String::from("hello world!");
    foo(&s);
}
fn foo(s: &str) {
    println!("{}", s);
}

+ 号运算

字符串 + 号运算是 String 的一个内联函数，定义如下：

1
2
3
4
5
6
7
8
9

impl Add<&str> for String {
    type Output = String;

    #[inline]
    fn add(mut self, other: &str) -> String {
        self.push_str(other);
        self
    }
}

所以两个字面量字符串（&str）不能使用 +，例如："hello " + "world"; 会报错误： '+' cannot be used to concatenate two '&str' strings。

根据 + 的定义，一个可变的 String 字符串进行 + 后会失去所有权，例如：

1
2
3
4
5

let mut s = String::from("hello world!");
let s1 = s + " welcome.";

// println!("{}, {}", s, s1);
//                    ^ value borrowed here after move

以上代码会出现以下警告：

1
2
3
4
5
6
7

//   |
//   |     let mut s = String::from("hello world!");
//   |         ----^
//   |         |
//   |         help: remove this `mut`
//   |
//   = note: #[warn(unused_mut)] on by default

查阅说是有 #[warn(unused_mut)] 注解后 variable does not need to be mutable。去掉以上代码中 String 定义时候用以标识可变的 mut 关键字就可以了。不太明白为啥可以这样，待日后详查。

接下来想到了第二种解决方案，能够保证 10（基数） 倍的流量比例正好是 3:7，思路如下：

1、生成 0 - 99 的数组（集合）
2、打乱数组（集合）的顺序，为了防止出现某比例的流量集中出现
3、全局的计数器，要考虑原子性
4、从数组（集合）中取出计数器和 100 取余后位置的值
5、判断取到的值落在那个区间

以下是 Java 版本的 2:3:5 比例分流的简单实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

package io.github.ehlxr.rate;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.IntStream;

/**
 * 按比例控制流量
 *
 * @author ehlxr
 * @since 2019-07-19.
 */
public class RateBarrier {
    private final AtomicInteger op = new AtomicInteger(0);
    private List<Integer> source;
    private int base;

    public int rate() {
        return source.get(op.incrementAndGet() % base);
    }

    private RateBarrier() {
    }

    public RateBarrier(int base) {
        this.base = base;

        source = new ArrayList<>(base);
        for (int i = 0; i < base; i++) {
            source.add(i);
        }

        // 打乱集合顺序
        Collections.shuffle(source);
    }

    public static void main(String[] args) {
        RateBarrier rateBarrier = new RateBarrier(10);

        IntStream.range(0, 20).parallel().forEach(i -> {
            int rate = rateBarrier.rate();
            if (rate < 2) {
                System.out.println("this is on 2");
            } else if (rate < 5) {
                System.out.println("this is on 3");
            } else {
                System.out.println("this is on 5");
            }
        });

        // final Thread[] threads = new Thread[20];
        // for (int i = 0; i < threads.length; i++) {
        //     threads[i] = new Thread(() -> {
        //         if (rateBarrier.allow()) {
        //             System.out.println("this is on 3");
        //         } else {
        //             System.out.println("this is on 7");
        //         }
        //     });
        //     threads[i].start();
        // }
        //
        // for (Thread t : threads) {
        //     try {
        //         t.join();
        //     } catch (InterruptedException e) {
        //         e.printStackTrace();
        //     }
        // }

    }
}

// Output:

/*
this is on 3
this is on 3
this is on 5
this is on 2
this is on 5
this is on 5
this is on 5
this is on 3
this is on 3
this is on 3
this is on 5
this is on 2
this is on 2
this is on 5
this is on 5
this is on 5
this is on 5
this is on 3
this is on 2
this is on 5
*/