嵌入式Hazelcast：如何定向数据至LocalMember及分配键至本地分区

Great to see you already digging into partition ownership logic—let's turn that code snippet into a working solution for your two requirements.

1. How to Always Send Data to the Local Member Instance #

The key here is controlling which partition your keys are routed to, since Hazelcast stores data based on partition ownership. Since you've already retrieved the list of partitions owned by the local member (pls), we just need to map your business keys to these partitions.

The most straightforward way is using Hazelcast's PartitionAware interface, which lets you define exactly which partition a key belongs to. Alternatively, you can use a custom PartitioningStrategy for global map-level control.

2. Can We Assign Keys to Partitions Owned by the Local Member? #

Absolutely! This is exactly how you enforce strict data locality. By tying your keys to partitions owned by the local member, you ensure read/write operations never leave the local node.

Working Implementation Using PartitionAware Keys #

First, let's build on your existing code to map keys to local partitions. We'll create a wrapper key class that implements PartitionAware, and use "anchor keys" that are guaranteed to land in your local partitions.

Step 1: Helper Method to Get Anchor Keys for Local Partitions

An anchor key is a dummy key that we pre-test to confirm it lands in a specific local partition. We'll use these anchors to route our real business keys:

private Object getAnchorKeyForPartition(PartitionService partitionService, int partitionId) {
    // Iterate to find a key that maps to the target partition (adjust logic if needed)
    for (int i = 0; i < 1000; i++) {
        String testKey = "local-anchor-" + partitionId + "-" + i;
        if (partitionService.getPartitionId(testKey) == partitionId) {
            return testKey;
        }
    }
    throw new IllegalStateException("Failed to find anchor key for partition " + partitionId);
}

Step 2: Custom PartitionAware Key Wrapper

This wrapper will use the anchor key to ensure your business key lands in the desired local partition:

import com.hazelcast.core.PartitionAware;
import java.util.Objects;

class LocalPartitionKey<T> implements PartitionAware {
    private final T actualKey;
    private final Object anchorKey;

    public LocalPartitionKey(T actualKey, Object anchorKey) {
        this.actualKey = actualKey;
        this.anchorKey = anchorKey;
    }

    // Expose the real business key for retrieval
    public T getActualKey() {
        return actualKey;
    }

    @Override
    public Object getPartitionKey() {
        // Use the anchor key to route to the correct local partition
        return anchorKey;
    }

    // Override equals/hashCode to ensure we use the actual key for map operations
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        LocalPartitionKey<?> that = (LocalPartitionKey<?>) o;
        return Objects.equals(actualKey, that.actualKey);
    }

    @Override
    public int hashCode() {
        return Objects.hash(actualKey);
    }
}

Step 3: Implement Your allotKeys Method

Now tie it all together to assign your business keys to local partitions:

private void allotKeys(List<Integer> localPartitionIds, PartitionService partitionService) {
    // Pre-generate anchor keys for each local partition
    Map<Integer, Object> partitionToAnchor = new HashMap<>();
    for (int partitionId : localPartitionIds) {
        partitionToAnchor.put(partitionId, getAnchorKeyForPartition(partitionService, partitionId));
    }

    // Example: List of business keys to assign
    List<String> businessKeys = List.of("user:101", "product:202", "order:303");

    // Assign keys to local partitions (here we use round-robin; adjust for your logic)
    int partitionIndex = 0;
    IMap<Object, String> localDataMap = instance.getMap("local-only-data");
    
    for (String key : businessKeys) {
        int targetPartition = localPartitionIds.get(partitionIndex % localPartitionIds.size());
        Object anchor = partitionToAnchor.get(targetPartition);
        
        // Wrap the business key and store it
        LocalPartitionKey<String> localKey = new LocalPartitionKey<>(key, anchor);
        localDataMap.put(localKey, "data-for-" + key);
        
        partitionIndex++;
    }
}

Alternative: Global PartitioningStrategy for All Map Keys #

If you want all keys in a map to automatically route to local partitions, use a custom PartitioningStrategy:

import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.Member;
import com.hazelcast.core.Partition;
import com.hazelcast.core.PartitionService;
import com.hazelcast.nio.serialization.PartitioningStrategy;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class LocalOnlyPartitioningStrategy implements PartitioningStrategy {
    private final List<Integer> localPartitionIds;
    private final Map<Integer, Object> partitionAnchors;

    public LocalOnlyPartitioningStrategy(HazelcastInstance instance) {
        PartitionService partitionService = instance.getPartitionService();
        Member localMember = instance.getCluster().getLocalMember();
        
        // Get local partitions (same as your original code)
        this.localPartitionIds = partitionService.getPartitions().stream()
                .filter(p -> localMember.getUuid().equals(p.getOwner().getUuid()))
                .map(Partition::getPartitionId)
                .collect(Collectors.toList());
        
        // Pre-generate anchors for each local partition
        this.partitionAnchors = new HashMap<>();
        for (int partitionId : localPartitionIds) {
            partitionAnchors.put(partitionId, getAnchorKeyForPartition(partitionService, partitionId));
        }
    }

    @Override
    public Object getPartitionKey(Object key) {
        // Route key to a random local partition (adjust logic for your use case)
        int hash = Math.abs(key.hashCode());
        int targetPartitionIndex = hash % localPartitionIds.size();
        int targetPartitionId = localPartitionIds.get(targetPartitionIndex);
        return partitionAnchors.get(targetPartitionId);
    }

    private Object getAnchorKeyForPartition(PartitionService partitionService, int partitionId) {
        for (int i = 0; i < 1000; i++) {
            String testKey = "global-anchor-" + partitionId + "-" + i;
            if (partitionService.getPartitionId(testKey) == partitionId) {
                return testKey;
            }
        }
        throw new IllegalStateException("No anchor key found for partition " + partitionId);
    }
}

Register this strategy in your Hazelcast config:

Config hazelcastConfig = new Config();
MapConfig mapConfig = hazelcastConfig.getMapConfig("local-only-data");
mapConfig.setPartitioningStrategy(new LocalOnlyPartitioningStrategy(instance));

Key Notes #

• Anchor Key Reliability: The anchor key method works because Hazelcast's partition calculation is deterministic for a given key. Once you find an anchor for a partition, it will always map to that partition.
• Partition Ownership Changes: If partitions rebalance (e.g., node joins/leaves), you'll need to re-fetch the local partition list and regenerate anchors. Consider listening to PartitionLostListener or MembershipListener to handle this dynamically.

内容的提问来源于stack exchange，提问作者Yukti Kaura