public class ConsistentHashing {
    private TreeMap<Integer, String> circle = new TreeMap<>();
    private List<String> nodes;
    private int numberOfVirtualNodes;
    
    public ConsistentHashing(List<String> nodes, int numberOfVirtualNodes) {
        this.nodes = nodes;
        this.numberOfVirtualNodes = numberOfVirtualNodes;
        initializeCircle();
    }
    
    private void initializeCircle() {
        for (String node : nodes) {
            for (int i = 0; i < numberOfVirtualNodes; i++) {
                String virtualNodeName = node + "&&VN" + i;
                int hash = getHash(virtualNodeName);
                circle.put(hash, node);
            }
        }
    }
    
    public String getServer(String key) {
        int hash = getHash(key);
        SortedMap<Integer, String> tailMap = circle.tailMap(hash);
        int serverHash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        return circle.get(serverHash);
    }
    
    private int getHash(String key) {
        final int p = 16777619;
        int hash = (int) 2166136261L;
        for (int i = 0; i < key.length(); i++) {
            hash = (hash ^ key.charAt(i)) * p;
        }
        hash += hash << 13;
        hash ^= hash >> 7;
        hash += hash << 3;
        hash ^= hash >> 17;
        hash += hash << 5;
        return Math.abs(hash);
    }
}

请求亲和性（Request Affinity）

请求亲和性是指将来自同一客户端或具有相同特征的请求始终分发到同一服务实例的机制。这种机制对于需要保持会话状态的应用非常重要。

会话保持的重要性

在许多Web应用中，服务器需要维护用户的会话状态，如购物车信息、登录状态等。如果用户的请求被分发到不同的服务器实例，就可能导致会话信息丢失。

实现方式

基于IP地址的亲和性

通过客户端IP地址实现请求亲和性：

public class IPBasedAffinity {
    private Map<String, String> ipToServerMap = new ConcurrentHashMap<>();
    
    public String getServerForIP(String clientIP) {
        // 检查是否已有映射
        if (ipToServerMap.containsKey(clientIP)) {
            return ipToServerMap.get(clientIP);
        }
        
        // 选择服务器并建立映射
        String server = selectServer();
        ipToServerMap.put(clientIP, server);
        return server;
    }
    
    private String selectServer() {
        // 实现服务器选择逻辑
        return "server1";
    }
}

基于Cookie的亲和性

通过HTTP Cookie实现请求亲和性：

public class CookieBasedAffinity {
    private static final String AFFINITY_COOKIE = "SERVER_AFFINITY";
    
    public String getServerForRequest(HttpServletRequest request) {
        // 检查请求中的Cookie
        Cookie[] cookies = request.getCookies();
        if (cookies != null) {
            for (Cookie cookie : cookies) {
                if (AFFINITY_COOKIE.equals(cookie.getName())) {
                    return cookie.getValue();
                }
            }
        }
        
        // 没有找到Cookie，选择新服务器
        String server = selectServer();
        // 设置响应Cookie
        setAffinityCookie(server);
        return server;
    }
    
    private void setAffinityCookie(String server) {
        // 在响应中设置Cookie
    }
    
    private String selectServer() {
        // 实现服务器选择逻辑
        return "server1";
    }
}

基于会话ID的亲和性

通过应用层会话ID实现请求亲和性：

public class SessionBasedAffinity {
    private Map<String, String> sessionToServerMap = new ConcurrentHashMap<>();
    
    public String getServerForSession(String sessionId) {
        // 检查是否已有映射
        if (sessionToServerMap.containsKey(sessionId)) {
            return sessionToServerMap.get(sessionId);
        }
        
        // 选择服务器并建立映射
        String server = selectServer();
        sessionToServerMap.put(sessionId, server);
        return server;
    }
}

一致性哈希与请求亲和性的结合

在实际应用中，一致性哈希和请求亲和性可以结合使用，以实现更好的负载均衡和会话保持效果。

实现方案

public class ConsistentHashingWithAffinity {
    private ConsistentHashing consistentHashing;
    private Map<String, String> affinityMap = new ConcurrentHashMap<>();
    private static final String AFFINITY_KEY = "AFFINITY_";
    
    public String getServer(String key, String clientId) {
        // 首先检查是否有亲和性映射
        String affinityKey = AFFINITY_KEY + clientId;
        if (affinityMap.containsKey(affinityKey)) {
            return affinityMap.get(affinityKey);
        }
        
        // 使用一致性哈希选择服务器
        String server = consistentHashing.getServer(key);
        
        // 建立亲和性映射
        affinityMap.put(affinityKey, server);
        
        return server;
    }
    
    public void removeAffinity(String clientId) {
        String affinityKey = AFFINITY_KEY + clientId;
        affinityMap.remove(affinityKey);
    }
}

实际应用场景

分布式缓存系统

在分布式缓存系统中，一致性哈希能够确保在节点增减时最小化缓存失效：

Memcached集群使用一致性哈希分布数据
Redis集群通过哈希槽实现类似效果
CDN系统使用一致性哈希分布内容

负载均衡器

在负载均衡器中，一致性哈希和请求亲和性能够实现高效的会话保持：

Nginx支持基于IP哈希的负载均衡
HAProxy支持多种会话保持机制
云服务商的负载均衡服务提供会话保持功能

数据库分片

在数据库分片场景中，一致性哈希能够实现数据的均匀分布：

MongoDB的分片机制
Elasticsearch的分片分布
各种分布式数据库的分片策略

性能优化考虑

哈希函数选择

选择合适的哈希函数对于一致性哈希的性能至关重要：

MurmurHash：性能好，分布均匀
CityHash：Google开发的高性能哈希函数
FNV Hash：简单快速的哈希函数

虚拟节点数量

虚拟节点数量需要根据实际情况进行调整：

过少：负载均衡效果差
过多：内存消耗大，查找效率低
通常建议：每个物理节点30-200个虚拟节点

缓存优化

通过缓存常用的映射关系提高性能：

public class OptimizedConsistentHashing {
    private final Map<String, String> cache = new ConcurrentHashMap<>();
    private final int cacheSize = 10000;
    
    public String getServer(String key) {
        // 首先检查缓存
        if (cache.containsKey(key)) {
            return cache.get(key);
        }
        
        // 计算并缓存结果
        String server = calculateServer(key);
        if (cache.size() < cacheSize) {
            cache.put(key, server);
        }
        
        return server;
    }
}

故障处理与恢复

节点故障处理

当节点发生故障时，需要重新分配其负责的数据：

public class FaultTolerantConsistentHashing {
    private Set<String> failedNodes = new HashSet<>();
    
    public String getServer(String key) {
        String server = consistentHashing.getServer(key);
        
        // 检查服务器是否故障
        if (failedNodes.contains(server)) {
            // 选择备用服务器
            return selectBackupServer(key, server);
        }
        
        return server;
    }
    
    private String selectBackupServer(String key, String failedServer) {
        // 实现备用服务器选择逻辑
        return "backupServer";
    }
}

节点恢复处理

当故障节点恢复时，需要重新建立映射关系：

public class NodeRecoveryHandler {
    public void handleNodeRecovery(String recoveredNode) {
        // 从故障节点列表中移除
        failedNodes.remove(recoveredNode);
        
        // 重新平衡负载
        rebalanceLoad(recoveredNode);
    }
    
    private void rebalanceLoad(String recoveredNode) {
        // 实现负载重新平衡逻辑
    }
}

监控与调优

性能监控

监控一致性哈希和请求亲和性的性能指标：

负载分布均匀性
缓存命中率
请求处理延迟
节点故障频率

动态调优

根据监控数据动态调整配置：

public class DynamicTuning {
    public void adjustVirtualNodeCount() {
        // 根据负载分布情况调整虚拟节点数量
        double variance = calculateLoadVariance();
        if (variance > threshold) {
            increaseVirtualNodes();
        } else if (variance < lowerThreshold) {
            decreaseVirtualNodes();
        }
    }
}

总结

一致性哈希和请求亲和性是分布式系统中重要的负载均衡和会话保持技术。一致性哈希通过构建虚拟哈希环解决了传统哈希算法在节点增减时的大量数据迁移问题，而请求亲和性则通过将相同特征的请求分发到同一实例实现了高效的会话保持。

在实际应用中，这两种技术经常结合使用，以在保持负载均衡的同时实现会话一致性。通过合理的设计和优化，可以构建出高性能、高可用的分布式系统。

随着云原生技术的发展，一致性哈希和请求亲和性也在不断演进，未来的系统可能会更多地采用智能化的负载均衡策略，结合机器学习和实时数据分析，为不同类型的请求提供最优的处理方案。