普通Hash算法/一致性Hash算法

public class ConsistentHash {
    // 定义服务器ip
    private static String[] tomcatServers = new String[]{"123.111.0.0", "123.101.3.1", "111.20.35.2", "123.98.26.3"};

    // 定义客户端IP
    private static String[] clients = new String[]{"10.78.12.3", "113.25.63.1", "126.12.3.8"};

    /**
     * 普通Hash
     */
    private static void generalHash() {
        // 定义服务器数量
        int serverCount = tomcatServers.length;// (编号对应0，1，2)

        // hash(ip)%node_counts=index
        //根据index锁定应该路由到的tomcat服务器
        System.out.println("==========>>>> GeneralHash <<<<==========");
        for (String client : clients) {
            int hash = Math.abs(client.hashCode());
            int index = hash % serverCount;
            System.out.println("客户端：" + client + " 被路由到服务器编号为：" + index + "(" + tomcatServers[index] + ")");
        }
    }

    /**
     * 一致性Hash算法 不含虚拟节点
     */
    private static void consistentHashNoVirtual() {
        //step1 初始化：把服务器节点IP的哈希值对应到哈希环上
        SortedMap<Integer, String> hashServerMap = new TreeMap<>();

        for (String tomcatServer : tomcatServers) {
            // 求出每一个ip的hash值，对应到hash环上，存储hash值与ip的对应关系
            int serverHash = Math.abs(tomcatServer.hashCode());
            // 存储hash值与ip的对应关系
            hashServerMap.put(serverHash, tomcatServer);
        }

        //step2 针对客户端IP求出hash值
        System.out.println("==========>>>> ConsistentHashNoVirtual <<<<==========");
        for (String client : clients) {
            int clientHash = Math.abs(client.hashCode());
            //step3 针对客户端,找到能够处理当前客户端请求的服务器（哈希环上顺时针最近）
            // 根据客户端ip的哈希值去找出哪一个服务器节点能够处理（）
            SortedMap<Integer, String> integerStringSortedMap = hashServerMap.tailMap(clientHash);
            if (integerStringSortedMap.isEmpty()) {
                // 取哈希环上的顺时针第一台服务器
                Integer firstKey = hashServerMap.firstKey();
                System.out.println("客户端：" + client + " 被路由到服务器：" + hashServerMap.get(firstKey));
            } else {
                Integer firstKey = integerStringSortedMap.firstKey();
                System.out.println("客户端：" + client + " 被路由到服务器：" + hashServerMap.get(firstKey));
            }
        }
    }

    /**
     * 一致性Hash算法 含虚拟节点
     */
    private static void consistentHashWithVirtual() {
        //step1 初始化：把服务器节点IP的哈希值对应到哈希环上
        SortedMap<Integer, String> hashServerMap = new TreeMap<>();

        // 定义针对每个真实服务器虚拟出来几个节点
        int virtualCount = 3;

        for (String tomcatServer : tomcatServers) {
            // 求出每一个ip的hash值，对应到hash环上，存储hash值与ip的对应关系
            int serverHash = Math.abs(tomcatServer.hashCode());
            // 存储hash值与ip的对应关系
            hashServerMap.put(serverHash, tomcatServer);

            // 处理虚拟节点
            for (int i = 0; i < virtualCount; i++) {
                int virtualHash = Math.abs((tomcatServer + "#" + i).hashCode());
                hashServerMap.put(virtualHash, "----由虚拟节点" + i + "映射过来的请求：" + tomcatServer);
            }

        }

        //step2 针对客户端IP求出hash值
        System.out.println("==========>>>> ConsistentHashWithVirtual <<<<==========");
        for (String client : clients) {
            int clientHash = Math.abs(client.hashCode());
            //step3 针对客户端,找到能够处理当前客户端请求的服务器（哈希环上顺时针最近）
            // 根据客户端ip的哈希值去找出哪一个服务器节点能够处理（）
            SortedMap<Integer, String> integerStringSortedMap = hashServerMap.tailMap(clientHash);
            if (integerStringSortedMap.isEmpty()) {
                // 取哈希环上的顺时针第一台服务器
                Integer firstKey = hashServerMap.firstKey();
                System.out.println("客户端：" + client + " 被路由到服务器：" + hashServerMap.get(firstKey));
            } else {
                Integer firstKey = integerStringSortedMap.firstKey();
                System.out.println("客户端：" + client + " 被路由到服务器：" + hashServerMap.get(firstKey));
            }
        }
    }

    /**
     * Hash算法,性能高,碰撞率低
     *
     * @param key String
     * @return Long
     */
    public static Long hash(String key) {
        ByteBuffer buf = ByteBuffer.wrap(key.getBytes());
        int seed = 0x1234ABCD;

        ByteOrder byteOrder = buf.order();
        buf.order(ByteOrder.LITTLE_ENDIAN);

        long m = 0xc6a4a7935bd1e995L;
        int r = 47;

        long h = seed ^ (buf.remaining() * m);

        long k;
        while (buf.remaining() >= 8) {
            k = buf.getLong();

            k *= m;
            k ^= k >>> r;
            k *= m;

            h ^= k;
            h *= m;
        }

        if (buf.remaining() > 0) {
            ByteBuffer finish = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);
            finish.put(buf).rewind();
            h ^= finish.getLong();
            h *= m;
        }

        h ^= h >>> r;
        h *= m;
        h ^= h >>> r;

        buf.order(byteOrder);
        return h;
    }

    public static void main(String[] args) {
        // 普通Hash算法
        generalHash();
        // 一致性Hash算法 不含虚拟节点
        consistentHashNoVirtual();
        // 一致性Hash算法 含虚拟节点
        consistentHashWithVirtual();

        long hashCode = hash("1");
        System.out.println("Hash:" + hashCode);
    }
}