...
Code Block | ||||
---|---|---|---|---|
| ||||
ignite:
enabled: true
clients:
default:
path: "classpath:a.cfg"
other:
path: "classpath:b.cfg"
|
A bean for the ignite instance the IgniteConfiguration can be provided from a factory.
Example:
Code Block | ||
---|---|---|
| ||
@Factory public class IgniteInitial { @Singleton @Bean @Primary @Named("default") IgniteConfiguration defaultConfiguration() { IgniteConfiguration cfg = new IgniteConfiguration(); // The node will be started as a client node. cfg.setClientMode(true); // Setting up an IP Finder to ensure the client can locate the servers. TcpDiscoveryMulticastIpFinder ipFinder = new TcpDiscoveryMulticastIpFinder(); ipFinder.setAddresses(Collections.singletonList("localhost:47500..47509")); cfg.setDiscoverySpi(new TcpDiscoverySpi().setIpFinder(ipFinder)); return cfg; } } |
...
Micronaut cache configuration is covered under snapshot documentation.
Micronaut by default will use By default the primary Ignite instance and use the DynamicCacheManager where the key will refer to the name of the IgniteCache instance.
...
is used for Micronaut cache and the key from for each cache operation will use name of the IgniteCache instance.
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
@Singleton
public class IgniteCacheManager implements DynamicCacheManager<IgniteCache> {
private final Ignite ignite;
private final ConversionService<?> service;
private final ExecutorService executorService;
public IgniteCacheManager(@Primary Ignite ignite,
ConversionService<?> service,
@Named(TaskExecutors.IO) ExecutorService executorService) {
this.ignite = ignite;
this.service = service;
this.executorService = executorService;
}
@NonNull
@Override
public SyncCache<IgniteCache> getCache(String name) {
return new IgniteSyncCache(service, ignite.getOrCreateCache(name), executorService);
}
}
|
This is an example of a service using Micronaut Cache.
Code Block | ||||||
---|---|---|---|---|---|---|
| ||||||
@Singleton @CacheConfig('counter') static class CounterService { Map<String, Integer> counters = new LinkedHashMap<>() Map<String, Integer> counters2 = new LinkedHashMap<>() int incrementNoCache(String name) { int value = counters.computeIfAbsent(name, { 0 }) counters.put(name, ++value) return value } @CachePut int increment(String name) { int value = counters.computeIfAbsent(name, { 0 }) counters.put(name, ++value) return value } @PutOperations([ @CachePut('counter'), @CachePut('counter2') ]) int increment2(String name) { int value = counters2.computeIfAbsent(name, { 0 }) counters2.put(name, ++value) return value } @Cacheable CompletableFuture<Integer> futureValue(String name) { return CompletableFuture.completedFuture(counters.computeIfAbsent(name, { 0 })) } @Cacheable @SingleResult Flowable<Integer> flowableValue(String name) { return Flowable.just(counters.computeIfAbsent(name, { 0 })) } @Cacheable Single<Integer> singleValue(String name) { return Single.just(counters.computeIfAbsent(name, { 0 })) } @CachePut CompletableFuture<Integer> futureIncrement(String name) { int value = counters.computeIfAbsent(name, { 0 }) counters.put(name, ++value) return CompletableFuture.completedFuture(value) } @Cacheable int getValue(String name) { return counters.computeIfAbsent(name, { 0 }) } @Cacheable('counter2') int getValue2(String name) { return counters2.computeIfAbsent(name, { 0 }) } @Cacheable Optional<Integer> getOptionalValue(String name) { return Optional.ofNullable(counters.get(name)) } @CacheInvalidate(all = true) void reset() { counters.clear() } @CacheInvalidate void reset(String name) { counters.remove(name) } @InvalidateOperations([ @CacheInvalidate('counter'), @CacheInvalidate('counter2') ]) void reset2(String name) { counters.remove(name) } @CacheInvalidate(parameters = 'name') void set(String name, int val) { counters.put(name, val) } } |
...