zhangqian
2023-12-08 e673885c64d5645c2c38e10ddfd922657afdc4cb
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
package snowflake
 
import (
    "apsClient/pkg/logx"
    "fmt"
    "github.com/bwmarrin/snowflake"
    "hash/fnv"
    "net"
)
 
var Node *snowflake.Node
 
func Init(nodeId int64) error {
    // Create a new Node with a Node number of 0~1023
    var err error
    Node, err = snowflake.NewNode(nodeId)
    if err != nil {
        logx.Errorf("snowflake NewNode error:%v", err)
        return err
    }
    return nil
}
 
func InitWithIP() {
    // 使用 LookupIP 获取主机的 IP 地址列表
    // 获取本机所有网络接口
    interfaces, err := net.Interfaces()
    if err != nil {
        logx.Errorf("snowflake InitWithIP error:%v", err)
        return
    }
 
    var ip string
    // 遍历所有网络接口
    for _, iface := range interfaces {
        // 排除一些特殊的接口,例如 loopback 接口
        if iface.Flags&net.FlagUp != 0 && iface.Flags&net.FlagLoopback == 0 {
            // 获取接口的所有地址
            addrs, err := iface.Addrs()
            if err != nil {
                logx.Errorf("snowflake InitWithIP error:%v", err)
                continue
            }
            // 遍历接口的所有地址
            for _, addr := range addrs {
                // 检查地址类型是否是 IP 地址
                if ipNet, ok := addr.(*net.IPNet); ok && !ipNet.IP.IsLoopback() {
                    // 判断 IP 地址的版本是 IPv4 还是 IPv6
                    if ipNet.IP.To4() != nil {
                        fmt.Printf("IPv4 Address: %s\n", ipNet.IP.String())
                        if ipNet.IP.String() != "127.0.0.1" {
                            ip = ipNet.IP.String()
                            goto getIpOK
                        }
                    } else {
                        fmt.Printf("IPv6 Address: %s\n", ipNet.IP.String())
                    }
                }
            }
        }
    }
getIpOK:
    if ip == "" {
        logx.Errorf("snowflake InitWithIP can not find Ip")
        return
    }
    ipNumber, err := ipToNumber(ip)
    if err != nil {
        logx.Errorf("snowflake can not generate, init error, ip to number error :%v", err)
        panic(fmt.Sprintf("snowflake can not generate, init error, ip to number error :%v", err))
    }
    err = Init(ipNumber)
    if err != nil {
        logx.Errorf("snowflake can not generate, init error :%v", err)
        panic(fmt.Sprintf("snowflake can not generate, init error :%v", err))
    }
}
 
func StringToNumber(input string) (int64, error) {
    hash := fnv.New32a()
    _, err := hash.Write([]byte(input))
    if err != nil {
        return 0, err
    }
    return int64(hash.Sum32() % 1024), nil // 取余数确保结果在 1 到 1023 之间
}
 
func ipToNumber(ip string) (int64, error) {
    // 将 IP 地址字符串解析为 net.IP 类型
    parsedIP := net.ParseIP(ip)
    if parsedIP == nil {
        return 0, fmt.Errorf("invalid IP address:%v", ip)
    }
 
    // 使用 FNV-1a 散列算法计算哈希值
    hash := fnv.New32a()
    hash.Write(parsedIP)
    return int64(hash.Sum32() % 1024), nil // 取余数确保结果在 1 到 1023 之间
}
 
func GenerateID() int64 {
    if Node == nil {
        InitWithIP()
    }
    return int64(Node.Generate())
}