客户端-服务器拓扑下，Java客户端如何实现Hazelcast IMap加载MongoDB数据

Great question! When moving from an embedded Hazelcast topology to client-server, the key thing to understand is that MapStore/MapLoader components run on the Hazelcast server nodes, not the Java client—this is a big shift from embedded where everything lives in the same process. Here's how to replicate your MongoDB data loading logic in client-server mode:

Your implementation will look almost identical to the embedded version, but this class needs to live on the Hazelcast server nodes (not the client). This is where you’ll handle all MongoDB interactions:

public class MongoDBMapStore implements MapStore<String, YourEntity>, MapLoaderLifecycleSupport {
    private MongoClient mongoClient;
    private MongoCollection<Document> collection;

    @Override
    public void init(HazelcastInstance hazelcastInstance, Properties properties, String mapName) {
        // Pull MongoDB config from server properties and initialize connection
        String connectionString = properties.getProperty("mongodb.connection.string");
        String dbName = properties.getProperty("mongodb.db.name");
        String collectionName = properties.getProperty("mongodb.collection.name");
        
        mongoClient = MongoClients.create(connectionString);
        collection = mongoClient.getDatabase(dbName).getCollection(collectionName);
    }

    @Override
    public YourEntity load(String key) {
        // Load single record from MongoDB and map to your entity
        Document doc = collection.find(eq("_id", key)).first();
        return doc != null ? mapDocumentToEntity(doc) : null;
    }

    @Override
    public Map<String, YourEntity> loadAll(Collection<String> keys) {
        // Efficiently load multiple records
        List<Document> docs = collection.find(in("_id", keys)).into(new ArrayList<>());
        return docs.stream()
                   .collect(Collectors.toMap(doc -> doc.getString("_id"), this::mapDocumentToEntity));
    }

    @Override
    public Iterable<String> loadAllKeys() {
        // Return all keys in the collection (use cautiously for large datasets!)
        return collection.find().map(doc -> doc.getString("_id"));
    }

    // Implement write methods if you need write-through/write-behind behavior
    @Override
    public void store(String key, YourEntity value) {
        collection.replaceOne(eq("_id", key), mapEntityToDocument(value), new ReplaceOptions().upsert(true));
    }

    @Override
    public void delete(String key) {
        collection.deleteOne(eq("_id", key));
    }

    // Helper mapping methods (use Jackson/ModelMapper or manual mapping as needed)
    private YourEntity mapDocumentToEntity(Document doc) {
        YourEntity entity = new YourEntity();
        entity.setId(doc.getString("_id"));
        entity.setName(doc.getString("name"));
        // Map other fields here
        return entity;
    }

    private Document mapEntityToDocument(YourEntity entity) {
        Document doc = new Document();
        doc.put("_id", entity.getId());
        doc.put("name", entity.getName());
        // Map other fields here
        return doc;
    }

    @Override
    public void destroy() {
        // Clean up MongoDB connection on node shutdown
        if (mongoClient != null) {
            mongoClient.close();
        }
    }
}

You need to tell Hazelcast servers about your MapStore implementation and pass MongoDB configuration details. This can be done via XML or programmatic config:

XML Configuration (hazelcast.xml) #

<hazelcast>
    <map name="your-target-map">
        <map-store enabled="true">
            <class-name>com.yourcompany.MongoDBMapStore</class-name>
            <properties>
                <property name="mongodb.connection.string">mongodb://localhost:27017</property>
                <property name="mongodb.db.name">your-database</property>
                <property name="mongodb.collection.name">your-collection</property>
            </properties>
            <!-- Optional: Preload all data when the map initializes -->
            <load-on-startup>true</load-on-startup>
            <!-- Set to 0 for write-through, >0 for write-behind -->
            <write-delay-seconds>0</write-delay-seconds>
        </map-store>
    </map>
</hazelcast>

Programmatic Server Configuration #

Config config = new Config();
MapConfig mapConfig = config.getMapConfig("your-target-map");
MapStoreConfig mapStoreConfig = mapConfig.getMapStoreConfig();

mapStoreConfig.setEnabled(true)
              .setClassName("com.yourcompany.MongoDBMapStore")
              .setProperty("mongodb.connection.string", "mongodb://localhost:27017")
              .setProperty("mongodb.db.name", "your-database")
              .setProperty("mongodb.collection.name", "your-collection")
              .setLoadOnStartup(true);

HazelcastInstance serverInstance = Hazelcast.newHazelcastInstance(config);

The client has no responsibility for data loading—it just connects to the cluster and uses the IMap like normal. All MapStore/Loader logic runs on the server nodes automatically:

// Configure and initialize the Hazelcast client
ClientConfig clientConfig = new ClientConfig();
clientConfig.getNetworkConfig().addAddress("localhost:5701", "localhost:5702"); // Add your server addresses

HazelcastInstance client = HazelcastClient.newHazelcastClient(clientConfig);
IMap<String, YourEntity> map = client.getMap("your-target-map");

// When you call get(), the server loads data from MongoDB if it's not cached
YourEntity entity = map.get("sample-key");

// Write operations trigger MapStore's store() method on the server
map.put("new-key", new YourEntity("new-key", "Sample Value"));

• Server-Side Dependencies: Ensure your MongoDBMapStore class and MongoDB driver JARs are present in the classpath of every Hazelcast server node (add them to the lib folder if using standalone servers).
• Load-on-Startup: Use this setting carefully for large datasets—it can increase server startup time.
• Connection Management: The init() and destroy() methods in MapLoaderLifecycleSupport are ideal for setting up and cleaning up MongoDB connections to avoid leaks.

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