Versions Compared

Old Version 3

changes.mady.by.user Michael Pollind

Saved on

compared with

New Version 4

changes.mady.by.user Michael Pollind

Saved on

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.

...

Design

Micronaut is a microservice microservice framework for building moudlar applications. This develops a module to configure and setup ignite to work with Micronaut and it's associated API's.

AutoConfiguration

IgniteClientConfiguration

Configuration to load Ignite instance.

...

languagejava
titleIgniteClientConfiguration
collapsetrue

...

configuration that bests works with Micronaut.

Auto-Configuration

...

Application yaml configuration.

Code Block
languageyml
titleexample config
ignite: 
	enabled: true
	clients:
		default:
			path: "classpath:a.cfg"         
		other:            
			path: "classpath:b.cfg"
  • default is the primary bean
  • path loads in a spring bean definition

...

Ignite factory configuration

A bean for the IgniteConfiguration an IgniteConfiguration can be provided from a factory.

Example:
Code Block
languagejava
@Factory
public class IgniteInitialMyFactory {
    @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

...

Ignite Cache

Micronaut cache configuration cache  is covered under snapshot documentation. By default the primary Ignite instance is used for Micronaut cache and the key from for each cache operation will use name of refer to the IgniteCache instance.

...

Code Block
languagejava
titleExample Cacheable Object
collapsetrue
  	@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)
        }
    }


Micronaut Ignite Application