29 Eylül 2022 Perşembe

HazelcastAPI NetworkConfig Sınıfı

Giriş
Şu satırı dahil ederiz
import com.hazelcast.config.NetworkConfig;
Örnek
Açıklaması şöyle
With network configuration, you can set Hazelcast cluster member port numbers and enable/disable the auto-increment mechanism for new cluster members, etc. In this example configuration, we set the default port to 5900 and disable the port auto increment option. ( Hazelcast default port is 5701)
addOutboundPort metodu
Şöyle yaparız
Config config = new Config();
config.getNetworkConfig().addOutboundPort(0);
getIcmpFailureDetectorConfig metodu

setJoin metodu
JoinConfig nesnesi atar

setPort metodu
Şöyle yaparız
NetworkConfig networkConfig = new NetworkConfig()
  .setPort(5900)  
  .setPortAutoIncrement(false);
setRestApiConfig metodu
RestApiConfig nesnesi atar

setSocketInterceptorConfig metodu




HazelcastAPI Config Sınıfı

Giriş
Şu satırı dahil ederiz
import com.hazelcast.config.Config;

Örnek
Şöyle yaparız
Config config = new Config();
config.setNetworkConfig(getHazelcastNetworkConfig());
config.setClusterName("hazelcast-cluster");
config.setInstanceName("hazelcast-template");
config.setPartitionGroupConfig(getPartitionGroupConfig());
config.setProperty("hazelcast.health.monitoring.level","NOISY");
config.addMapConfig(getHazelcastMapConfig());
addCacheConfig metodu
CacheSimpleConfig nesnesi ekler

addExecutorConfig metodu
ExecutorConfig nesnesi ekler

addQueryCacheConfig metodu - mapName + QueryCacheConfig
QueryCacheConfig nesnesi ekler

addEventJournalConfig metodu
EventJournalConfig nesnesi ekler

addDataLinkConfig metodu
DataLinkConfig nesnesi ekler

addMapConfig metodu
MapConfig nesnesi ekler

addReplicatedMapConfig metodu

addRingBufferConfig metodu
RingBufferConfig nesnesi ekler

getAdvancedNetworkConfig metodu
AdvancedNetworkConfig nesnesi döner

getCPSubsystemConfig metodu
CPSubsystemConfig nesnesi döner

getJetConfig metodu
JetConfig nesnesi döner

getSecurityConfig metodu
SecurityConfig nesnesi döner.

getSerializationConfig metodu
SerializationConfig nesnesi döner.

setManagedContext metodu
ManagedContext arayüzünü atamak içindir. ManagedContext kalıtımı şöyle
ManagedContext
  HazelcastManagedContext
  HazelcastClientManagedContext

setLiteMember metodu
Lite Member yazısına taşıdım

Örnek
Şöyle yaparız
Config config = new Config();
config.setLiteMember(true);
setProperty metodu
Örnek
Şöyle yaparız
Config config = new Config();
config.setProperty(ClusterProperty.PARTITION_COUNT.getName(), "1");
config.setProperty(ClusterProperty.PARTITION_OPERATION_THREAD_COUNT.getName(), "1");


28 Eylül 2022 Çarşamba

HazelcastAPI Hazelcast Sınıfı - Hazelcast Member'ı Başlatır

Giriş
Şu satırı dahil ederiz
import com.hazelcast.core.Hazelcast;
bootstrappedInstance metodu
Bence bu metodun tek amacı Jet Job içinde kullanmak. 
Örnek
Şöyle yaparız. Böylece Job client içinden de yüklense, member içinden de yüklense çalışabilir.
Pipeline pipeline = ...
HazelcastInstance hz = Hazelcast.bootstrappedInstance();

hz.getJet().newJob(pipeline);
getAllHazelcastInstances metodu
Şöyle yaparız
Set<HazelcastInstance> instances = Hazelcast.getAllHazelcastInstances();
HazelcastInstance hz = instances.stream().findFirst().get();
Map map = hz.getMap("mapName"); // shared distributed map
getOrCreateHazelcastInstance metodu
İmzası şöyle
public static HazelcastInstance getOrCreateHazelcastInstance();
Şöyle yaparız
import com.hazelcast.config.Config;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.IAtomicReference;
import com.hazelcast.core.IFunction;

Config config = new Config();
config.setInstanceName("HAZELCAST_INSTANCE");
HazelcastInstance hazelcastInstance = Hazelcast.getOrCreateHazelcastInstance(config);

IAtomicReference<String> atomicReference = hazelcastInstance.getAtomicReference("TEST");
String item = "A";
System.out.println("Item: " + atomicReference.alterAndGet(new MyFunction(item)));
getHazelcastInstanceByName metodu
Eğer ismi belirtilen instance'ı bulamazsa null döner.
Örnek
Şöyle yaparız
// You can also create a named Hazelcast member. 
// In this case, you should set instanceName of Config object as shown below
Config config = new Config();
config.setInstanceName( "my-instance" );
Hazelcast.newHazelcastInstance( config );

// To retrieve an existing Hazelcast member by its name, use the following
Hazelcast.getHazelcastInstanceByName( "my-instance" );
newHazelcastInstance metodu
Yeni member başlatır. Açıklaması şöyle. Yani gömülü bile olsa hazelcast.xml dosyasını belirtmek mümkün.
Hazelcast will look into two places for the configuration file:

1. System property: Hazelcast will first check if "hazelcast.config" system property is set to a file path. Example: 
  -Dhazelcast.config=C:/myhazelcast.xml.
2. Classpath: If config file is not set as a system property, Hazelcast will check classpath for hazelcast.xml file.
3. If Hazelcast doesn't find any config file, it will start with the default configuration (hazelcast-default.xml) located in hazelcast.jar.
Metodun için şöyle. Yani Config.load() çağrısı yapıyor. Bu yüzden hazelcast.xml içindeki değerler ortam değişkenleri tarafından ezilebilir. Configuration Builder ve Configuration Loader farklı şeyler
public static HazelcastInstance newHazelcastInstance() {
  return HazelcastInstanceFactory.newHazelcastInstance(null);
}

public static HazelcastInstance newHazelcastInstance(Config config) {
  if (config == null) {
    config = Config.load();
  }

  return newHazelcastInstance(
                config,
                config.getInstanceName(),
                new DefaultNodeContext()
  );
}
Örnek
Şöyle yaparız
HazelcastInstance hz = Hazelcast.newHazelcastInstance();
shutdownAll metodu
İmzası şöyle
public static void shutdownAll();
Aynı JVM içinde başlatılan tüm HazelcastInstance nesnelerini kapatır

Hazelcast Jet Nedir

Giriş 
Proje 2015 yılında başlamış ve ilk sürüm 2017 yılında yapılmış. IMDG ile bir sürü alt yapıyı paylaşıyor.
Aslında kısaca Stream Processing için kullanılıyor. Tanıtım sayfası dokümantasyon burada

Bazı basit kullanım örnekleri burada

Daha sonra Hazelcast Platform ortaya çıktı. Açıklaması şöyle. Ama ben bu yazıda Hazelcast Jet olarak yazmaya devam edeceğim.
What is Hazelcast Platform 5.0?

In the recent past, we observed emerging use cases that were a great fit for Hazelcast Jet such as digital integration hub or enrichment of streams of data with a static one. On the other hand, our world-class user base of Hazelcast IMDG continued to run the more traditional OLTP use cases.

Although Hazelcast Jet is built on top of Hazelcast IMDG, the split created massive confusion among our users about whether they should use IMDG or Jet in their particular case. In order to sort out this confusion, we decided to merge the Hazelcast IMDG and Hazelcast Jet products into a single one, simply named Hazelcast Platform.

In short, Hazelcast 5.0 can be thought of as a successor of Hazelcast IMDG 4.2 with added all the streaming and pipeline capabilities of Hazelcast Jet 4.5.

As a side note, you might come across the term “Hazelcast Platform” on our website and marketing materials. It’s a synonym for the newly merged Hazelcast 5.0+ product and is used in places where we need to distinguish between Hazelcast “the product” and Hazelcast “the company”.

Jet Job Command Pattern
Jet Job'ları çalıştırmak için Command Pattern uygulanıyor. Bunlara Operation deniliyor. Tüm sınıflar burada. Mesela bunlardan birisi SubmitJobOperation. Bir diğeri TerminateJobOperation

Bütün operation veya command'ler JobCoordinationService nesnesini çağırıyor

Job Submit
Pipeline'nın çalışan haline job deniyor. Bir Job sadece bir kere çalıştırılmalı

Task Parallelism Nedir?
Elimizde şöyle bir kod olsun
Pipeline p = Pipeline.create();
p.readFrom(Sources.<Long, String>map(BOOK_LINES))
  .flatMap(line -> traverseArray(line.getValue().split("\\W+")))
  .filter(word -> !word.isEmpty())
  .groupingKey(wholeItem())
  .aggregate(counting())
  .writeTo(Sinks.map(COUNTS));
Bu kod daha küçük Task'lara bölünerek şu hale gelir

İş çalışırken DAG olarak şunu görürüz. İlk olarak DAG'taki düğümler tanımlanır. localParallelism ile kaç tane worker tanımlandığını görürüz.
digraph DAG {
  "filesSource(/*)" [localParallelism=1];
  "fused(flat-map, filter)" [localParallelism=2];
  "group-and-aggregate-prepare" [localParallelism=2];
  "group-and-aggregate" [localParallelism=2];
  "loggerSink" [localParallelism=1];

  "filesSource(/*)" -> "fused(flat-map, filter)" [queueSize=1024];
  "fused(flat-map, filter)" -> "group-and-aggregate-prepare"
        [label="partitioned", queueSize=1024];
  subgraph cluster_0 {
    "group-and-aggregate-prepare" -> "group-and-aggregate"
    [label="distributed-partitioned", queueSize=1024];
  }
  "group-and-aggregate" -> "loggerSink" [queueSize=1024];
}
Data Parallelism Nedir?
DataSource'un farklı kısımlarının farklı cluster üyesi tarafından işlenmesi demek. Şeklen şöyle


Neticede elimize streaming yapısı geçiyor. Şeklen şöyle


Jet Pipeline Execution Model

Serialization of Data Types
Serialization of Data Types yazısına taşıdım

Serialization Of Pipeline
Pipeline içindeki nesnelerin başka bilgisayarlara dağıtılabilmesi için serializable olması gerekiyor. Lambda için açıklama şöyle
A typical Jet pipeline involves lambda expressions. Since the whole pipeline definition must be serialized to be sent to the cluster, the lambda expressions must be serializable as well. The Java standard provides an essential building block: if the static type of the lambda is a subtype of Serializable you will automatically get a lambda instance that can serialize itself.

None of the functional interfaces in the JDK extend Serializable so we had to mirror the entire java.util.function package in our own com.hazelcast.function with all the interfaces subtyped and made Serializable. Each subtype has the name of the original with Ex appended. For example, a FunctionEx is just like Function but implements Serializable. We use these types everywhere in the Pipeline API.
Jet Fault Tolerance
Jet Fault Tolerance yazısına taşıdım






26 Eylül 2022 Pazartesi

In-Memory Data Grid - IMDG Nedir ?

In-Memory Data Grid - IMDG  Nedir
Açıklaması şöyle
What is an In-Memory Data Grid (IMDG)?
First of all, let’s introduce the concept of Data Grid. A Data Grid is a system of multiple servers that work together to manage information and related operations in a distributed environment.

The servers from the grid can be located in the same location or distributed across multiple data centers.
Bir başka açıklama şöyle
It is distributed cache with computational capabilities and additional data structures
Yani IMDG 
1. Cache olarak kullanılır
2. Computation için kullanılır

Partition Yani Sharding
Bir soru ve cevap şöyle. Yani Hazelcast ile veri 271 parçaya bölünüyor
Q : Why hazelcast has default partition count of 271 and what are the parameters to chose one?

A : 271 is a prime number. And given any key, Hazelcast will hash the key and mod it with the partition count. In this context, prime numbers are believed to generate more pseudo-random result. Actually for user perspective, it is not that important to have it prime.
IMDG Kullanım Senaryoları
Açıklaması şöyle
There are two major use-cases for an In-Memory Data Grid: 
1. Data Cache
2. Data Service Fabric
Data Service Fabric Nedir
Açıklaması şöyle
By using the IMDG as a Data Service Fabric we can perform near real-time integration between multiple components of a system.
In this way, we achieve a lot of computing power which can help us in designing a responsive distributed system, which is the core of the entire reactive systems idea.
Leveraging the IMDG can allow us to use it as a messaging platform, basically performing in-memory streaming.
Hazelcast İki Farklı Şekilde IMDG Olarak Kullanılabilir
1. Embedded In Memory Data Grid
2. Client-Server

1. Embedded Kullanım
Açıklaması şöyle
An In-Memory Data Grid is a grid that stores data entirely into Random Access Memory (RAM).
Bu çalışma şeklinde her Hazelcast katılımcısı aynı zamanda Hazelcast Cluster'ının da bir parçası. Bu yüzden verinin bir kısmı belleğimizde saklanıyor ve işlemci gücü harcıyoruz.
Yani 
- Her JVM içinde bir Hazelcast vardır. 
- Eğer Hibernate Second Level Cache olarak kullanmak istersek com.hazelcast.hibernate.HazelcastCacheRegionFactory kullanılır

2. Client-Server
Bu çalışma şeklinde Hazelcast sunucularına istemci olarak bağlanıyoruz.

Hazelcast Cluster Nedir
Açıklaması şöyle. Cluster'da master-slave ilişkisi yoktur.
Hazelcast provides no single point of failure for data systems. What does this mean and how does Hazelcast achieve this? Because of the fact that it uses peer to peer communication between its members, there is no master-slave relations between cluster members. All cluster members configured in same way so any member can be replaced with other. (The first node created in the cluster manages cluster members, then the second oldest takes the responsibility if first node is down.)
Cluster'lar şu topolojide olabilir
Single Cluster That Spans Across Datacenter(s)
Single Cluster Per Datacenter
Single Clusters Per Region
Hazelcast Cluster Discovery Nasıldır
Açıklaması şöyle
As we have already seen, when talking about an IMDG, a very important aspect is the Cluster Discovery mechanism. Hazelcast provides multiple methods that can be used:

TCP/IP multicast discovery which is not recommended in a production environment;
TCP/IP unicast discovery which implies managing a static list of addresses of some members of the cluster;
Various discovery plugins for cloud, like Eureka, Zookeeper, Kubernetes, Openshift, Pivotal Cloud Foundry, Google Cloud Platform, Amazon Web Services, Microsoft Azure;
Implement a custom discovery mechanism via Discovery Service Provider Interface (SPI).
Açıklaması şöyle
Hazelcast provides different means of auto-discovery cluster members. For instance, for local (development) environment, the multicast mechanism over UDP allows members to find each other. So, it is possible to run locally several instances of the application and Hazelcast will be able to build a cluster using a multicast auto-discovery. This type of discovery is enabled as following:


 Veri Yapıları Nelerdir
Açıklaması şöyleIMap yazısına bakabilirsiniz.
Besides all these, Hazelcast offers many distributed data structures such as standard utility collections : Map, Queue, Set, and List, Topic for pub/sub mechanisms. In addition to these, Concurrency utility data structures also is included in Hazelcast such as FencedLock, ISemaphore and so on. If already existed distributed data structures are not enough for your need, you can create your own distributed data structure by using Service Provider Interface which Hazelcast offers for users.


HazelcastAPI IMap Arayüzü

Giriş
Şu satırı dahil ederiz
import com.hazelcast.IMap;
ConcurrentMap ve dolayısıyla Map arayüzünden kalıtır. Açıklaması şöyle
The distributed map implementation has a method to lock a specific key. If the lock is not available, the current thread is blocked until the lock has been released. We can get a lock on the key even if it is not present in the map. If the key does not exist in the map, any thread apart from the lock owner will get blocked if it tries to put the locked key in the map.
Veri Nasıl Dağıtılır
Soru ve cevap şöyle. Dolayısıyla keySet() ve localKeySet() farklı şeyler yaparlar
Q : Does each member in the Hazelcast cluster maintain the information about the set of all keys in a given map or only about the subset of those keys in the partition(s) that it owns ?

A: Members do not maintain a global key set. Each member is aware of local entries only. Hence keySet() is a distributed operation hitting all members while localKeySet() is just a local operation.
External Data Store
IMap bellekte saklanır ancak veri tabanından okuma ve veri tabanına yazma imkanı da sağlar.
- To load data from external systems in a map you will use the Java MapLoader interface.
- To save map entries to an external system, you will use the Java MapStore interface.
Veri tabanından okuma ve ver tabanına yazma için MapStore Arayüzü yazısına bakabilirsiniz

Bazı IMap metodları Java metodlarındaki imzaları karşılamak için gereksiz MapStore/MapLoader çağrıları yapıyor. Bunlardan kaçınmak için IMap farklı metodlar sunuyor. Bunlar şöyle
IMap.remove() -> IMap.delete()
IMap.put() ->  IMap.putTransient()
IMap.containsKey() -> ?
Operation Objects
Açıklaması şöyle
Almost every operation on IMap is encapsulated into one of operation objects (see also: Command pattern). This operation is later dispatched to one or all cluster members and executed remotely in a separate thread pool, or even on a different machine.
DistributedObjectDestroyOperation : map.destroy() ile çağrılır
MapFetchEntriesOperation - Operation for fetching a chunk of entries from a single IMap partition

Transactional Operation Step Objects
Bir transaction içinde IMap'e yapılan adımlar (step)
Bunlar IMapOpStep arayüzünden kalıtıyor

Kullanım
Örnek
Şöyle yaparız
HazelcastInstance hazelcastInstance = ...;
ConcurrentMap<String, String> nameByEmailMap = hazelcastInstance.getMap("nameByEmail");
Açıklaması şöyle
In the fragment above, we are using Hazelcast's Distributed Map, which is presented and used in the code as ConcurrentMap. This gives a simple and flexible way to work with cached data as with simple map. All the heavy lifting to distribute cached data throughout the cluster Hazelcast performs behind the scenes. So, the usage of the cache as a map is fully transparent for developers.
Örnek
Şöyle yaparız. Spring ile JSON kullanmak için özel bir ayar yapmadıysak, Key ve Value nesnelerinin Serializable olması gerekir.
public class Doctor implements Serializable {
...
}

@Bean
public Map<String, Doctor> doctorMap(HazelcastInstance hazelcastInstance) {
  return hazelcastInstance.getMap("doctorMap");
}

@Autowired
private Map<String, Doctor> doctorMap;

@GetMapping(path = { "/get/{doctorNumber}" })
public Doctor getDoctor(@PathVariable("doctorNumber") String doctorNumber) {
  //First call is to check if doctormap has doctor details if yes,
//return the value otherwise call database.
  Doctor doctor = doctorMap.get(doctorNumber);
  if (doctor == null){
    doctor = ...; 
  }
  return doctor;
}

@PostMapping("/add")
public void createDoctor(@RequestBody Doctor doctor) {
  //save doctor details in cache
  doctorMap.put(doctor.getDoctorNumber(), doctor);
  ...
}
@DeleteMapping(path = { "/delete/{doctorNumber}" })
public Doctor deleteDoctor(@PathVariable("doctorNumber") String doctorNumber) {
  //remove doctor details from both cache and database
  doctorMap.remove(doctorNumber);
  ...
}
constructor
HazelcastInstance.getMap() tarafından döndürülür
Örnek
Şöyle yaparız
IMap<String, String> map = hazelcastInstance.getMap("my-map");
addEntryListener metodu
EntryListener nesnesi ekler. addEntryListener() yerine EntryListenerConfig kullanılabilir

addIndex metodu
addIndex metodu yazısına taşıdım

addInterceptor metodu
MapInterceptor nesnesi ekler

addLocalEntryListener metodu
addEntryListener metodu gibidir. Farklı olarak EntryListener bu member'da sadece kendi sahibi olduğu key değerler için tetiklenir. 

deleteAsync metodu
İmzası şöyle. Belirtilen key değerini asenkron olarak siler
CompletionStage<Boolean> deleteAsync(K key);
destroy metodu
Map'i siler
Örnek
Şöyle yaparız
instance.getMap(mapName).destroy();
executeOnEntries metodu
Açıklaması şöyle
When using the executeOnEntries method, if the number of entries is high and you do not need the results, then returning null with the process() method is a good practice. This method is offered by the EntryProcessor interface. By returning null, results of the processing are not collected and thus out of memory errors are eliminated.
Örnek
Şöyle yaparız
HazelcastInstance instance = Hazelcast.newHazelcastInstance();

IMap<Integer, String> map = instance.getMap("test");
map.set(1, "a");
map.set(2, "b");
map.set(3, "c");
//Result map does not have key = 1
Map<Integer, String> result = map.executeOnEntries(
  entry -> entry.getKey() > 1 ? entry.getValue() : null);
get metodu
Örnek
Şöyle yaparız
public String getDataByKey(String key) {
  IMap<String, String> map = hazelcastInstance.getMap("my-map");
  return map.get(key);
}
getAsync metodu
İmzası şöyle
CompletionStage<V> getAsync(K key);
Hemen value değerini döndürmez. Açıklaması şöyle
It may or may not be executed before calling future.get(), but it will block and will get the result when you call it if the result is still not there.
 Şöyle yaparız
CompletionStage future = map.getAsync(key);
// do some other stuff, when ready get the result.
Object value = future.toCompletableFuture().get();
getEntryView metodu
EntryView döner

keySet metodu - com.hazelcast.query.Predicate
Açıklaması şöyle
Predicate API doesn't support joins at all
Örnek
Şöyle yaparız
map.keySet(Predicates.equal(...));
localKeySet metodu
ClientMapProxy bu metod için exception fırlatıyor. 
MapProxyImpl ise bu member'daki keyset nesnesini döndürür


lock metodu - key
Sadece belirtilen key'in olduğu partition kilitlenir. Yani dağıtık bir lock değildir

Örnek
Şöyle yaparız
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.IMap;

HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance();
IMap txLockMap = hazelcast.getMap("txLockMap");
String lock = "...";
txLockMap.lock(key);

try {
  txLockMap.tryLock(key,10,TimeUnit.SECONDS);
} catch (Exception e){
  ...
}

txLockMap.isLocked(key);

try {
  txLockMap.unlock(key);
} catch (Exception e){
  ...
}
put metodu
Açıklaması şöyle
IMap.put and other modifying operations return success in case of backup timeout (hazelcast.operation.backup.timeout.millis) even if synchronous backup is configured for IMap. This is by design and described in the documentation.
Örnek
Şöyle yaparız
public String createData(String key, String value) {
  IMap<String, String> map = hazelcastInstance.getMap("my-map");
  map.put(key, value);
  return "Data is stored.";
}
putAll metodu
İmzası şöyle. Belitilen map nesnesinin tamamını IMap nesnesin ekler
void putAll(Map<? extends K, ? extends V> m);
Örnek
Şöyle yaparız
Map<Integer, Integer> entriesToAdd = new HashMap<>();

// Populate data structures
Random random = new Random();
IntStream.range(0, maxValue)
  .forEach(i -> {
    int value = random.nextInt();
    entriesToAdd.put(i, value);
  });
// Populate IMap
IMap<Integer, Integer> map = hz.getMap("map");
map.putAll(entriesToAdd);
putIfAbsent metodu
Örnek
Şöyle yaparız
HazelcastInstance hz = Hazelcast.newHazelcastInstance();
ConcurrentMap<String,String> map = hz.getMap("my-map");
map.put("key","value");
String value = map.get("key");
map.putIfAbsent("somekey","somevalue");
map.replace("key","value","newvalue");
putTransient metodu
İmzası şöyle
void putTransient(K key, V value, long ttl, TimeUnit ttlUnit);
void putTransient(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, 
  TimeUnit maxIdleUnit);
Birinci metod, belirtilen TTL kadar yaşayan bir key-value çiftini ekler. TTL en son yazma zamanını temel alır. TTL 0 ise bu çift bayatlamaz. Eksi bir değerse, MapConfiguration'da belirtilen değer kadar yaşar. Varsayılan değer 0 yani sonsuzdur. 

İkinci metod TTL yanında bir de maxIdle tanımlama imkanı tanıyor. maxIdle TTL gibidir ancak hem yazma hem de okuma zamanını temel alır. Buna göre key-value çiftinin bayatlaması hesaplanır

remove metodu
Örnek
Şöyle yaparız
public String deleteData(String key) {
  IMap<String, String> map = hazelcastInstance.getMap("my-map");
  return map.remove(key);
}
removeEntryListener metodu
İmzası şöyle
boolean removeEntryListener(UUID id);
addEntryListener() çağrısı sonucunda yeni eklenen listener için bir UUID döndürülür. Bu UUID ile listener silinebilir.
Örnek
Şöyle yaparız
IMap map = inst.getMap("map1");
UUID mapRegistrationId = map1.addEntryListener(...);
...
map.removeEntryListener(mapRegistrationId);
set metodu
Örnek
Şöyle yaparız
public String update(String key, String value) {
  IMap<String, String> map = hazelcastInstance.getMap("my-map");
  map.set(key, value);
  return "Data is stored.";
}
setAsync metodu
put() metodu gibidir. Belirtilen key ve value değerini asenkron olarak işler

values
İki tane metod var. Her ikisi de sonuçları heap te saklar
Collection<V> values();
Collection<V> values(@Nonnull Predicate<K, V> predicate);




THIRD-PARTY.txt Dosyası

Kullanılan harici kütüphanelerin sürümleri bu dosyada Dosyanın yolu şöyle hazelcast/licenses/THIRD-PARTY.txt