org.redisson.spring.support.redisson-1.1.xsd Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of redisson-all Show documentation
Easy Redis Java client and Real-Time Data Platform. Valkey compatible. Sync/Async/RxJava3/Reactive API. Client side caching. Over 50 Redis based Java objects and services: JCache API, Apache Tomcat, Hibernate, Spring, Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Bloom filter, Scheduler, RPC
There is a newer version: 3.40.2
Show newest version



    
    
        
        
        
    
    
     
        
            
                
                    
                
            
            
                
                    
                
            
            
                
                    
                
            
        
    
    
     
        
            
                
                    
                
            
            
                
                    
                
            
        
    
    
     
        
            
                
                    
                
            
            
                
                    
                
            
            
                
                    
                
            
            
                
                    
                
            
        
    
    
     
        
            
                
                    
                
            
            
                
                    
                
            
            
                
                    
                
            
            
                
                    
                
            
            
                
                    
                
            
            
                
                    
                
            
            
                
                    
                
            
        
    
    
     
        
            
                
                    
                
            
            
                
                    netty-tcnative lib is required to be in classpath.
                 ]]>
                
            
        
    
    
    
        
            
                
                    
                    
                
                
                    
                        <qualifier> is not used.
                     ]]>
                    
                
            
        
    
    
    
        
            
                
                    
                        
                    
                
                
                    
                        
                    
                
                
                    
                        
                    
                
                
                    
                        
                    
                
                
                    
                        
                    
                
                
                    
                        
                    
                
                
                    
                        
                    
                
                
                    
                        
                    
                
                
                    
                        
                    
                
            
        
    
    
    
        
            
                timeout time
        and current connections amount bigger than minimum idle connections pool
        size, then it will closed and removed from pool.
        Value in milliseconds.
        
        Default: 10000
             ]]>
            
        
        
            
                Node.ping and Node.pingAll
        operation. Value in milliseconds.
        
        Default: 1000
             ]]>
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                failedAttempts.

        Default: 3
             ]]>
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
    
    
    
        
            
                
                    
                        
                    
                
                
                    
                        each slave
        node.
        
        Default: 10
                     ]]>
                    
                
                
                    
                        each slave
        node.
        
        Default: 64
                     ]]>
                    
                
                
                    
                        each slave
        node.
        
        Default: 10
                     ]]>
                    
                
                
                    
                        
                    
                
                
                    
                        
                    
                
                
                    
                        
                    
                
                
                    
                        
                    
                
                
                    
                        
                    
                
            
        
    
    
    
        
            
                
                    
                
                
                    
                        
                    
                
            
        
    

    
        
            
                
                    
                        
                    
                
            
        
    

    
        
            
                
                    
                    
                    
                    
                    
                
            
        
    

    
        
            
                
            
        
    
    
    
        
            
                
                    
                        
                    
                
            
        
    
    
    
        
            
                
                    
                        
                    
                
            
        
    
    
    
        
            
                
                    
                        
                    
                
            
        
    
    
    
        
            
                
                    
                        
                    
                
            
        
    
    
    
        
            
                
                    
                        
                    
                
                
                    
                        
                    
                
            
        
    
    
    
        
            
                
            
        
        
            
                
            
        
    
    
    
        
            
                
            
        
        
            
                
            
        
    
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                    
                        
                            
        NB: applications must ensure the JVM DNS cache TTL is low enough to
        support this. e.g., http://docs.aws.amazon.com/AWSSdkDocsJava/latest/DeveloperGuide/java-dg-jvm-ttl.html
                            
        Default: false
                        ]]>
                        
                    
                    
                        
                            
                        
                    
                
            
        
    

    
        
            
        
        
            
                
                    
                        
                    
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                
            
        
    

    
        
            
        
        
            
                
                    
                        
                    
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                
            
        
    

    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
                
                    
                        
                    
                    
                        
                            true then invalidation
        message which removes corresponding entry from cache will be sent to all
        other RLocalCachedMap instances on each entry update/remove operation.
        if false then invalidation message won't be sent.
                         ]]>
                        
                    
                    
                        
                            LRU - uses cache with LRU (least recently used) eviction
                policy.
        LFU - uses cache with LFU (least frequently used)
                eviction policy.
        
SOFT - uses cache with soft references. The garbage
                collector will evict items from the cache when the JVM is
                running out of memory. JVM flag -XX:SoftRefLRUPolicyMSPerMB=???
                is required to function.
        
NONE - doesn't use eviction policy, but timeToLive and
                maxIdleTime params are still working.
                         ]]>
                        
                    
                    
                        
                            0 then local cache is unbounded.
                 ]]>
                        
                    
                    
                        
                            0 then timeout is not applied.
        
        Default unit is MILLISECONDS
                         ]]>
                        
                    
                    
                        
                            
                        
                    
                    
                        
                            0 then timeout is not applied.
        
        Default unit is MILLISECONDS
                         ]]>
                        
                    
                    
                        
                            
                        
                    
                
            
        
    
    
    
        
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
                    
                        
                            
                            
                        
                        
                            
                            
                        
                    
                
            
        
    
    
    
        
            NOT mandatory
        since the class will also be registered lazily when it is first used.
        
        All classed registered with the service is stored in a class cache.
        
        The cache is independent between different RedissonClient instances. When
        a class is registered in one RLiveObjectService instance it is also
        accessible in another RLiveObjectService instance so long as they are 
        created by the same RedissonClient instance.
         ]]>
        
        
            
                
                    
                
            
            
                
                    
                
            
        
    
    
    
        
            NOT mandatory
        since the class will also be registered lazily when it is first used.
        
        All classed registered with the service is stored in a class cache.
        
        The cache is independent between different RedissonClient instances. When
        a class is registered in one RLiveObjectService instance it is also
        accessible in another RLiveObjectService instance so long as they are 
        created by the same RedissonClient instance.
        
        One of "object-id" or "object-id-ref" attribute is required.
         ]]>
        
        
            
                
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                
            
        
    
    
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            Set eviction
        
        Redisson distributed Set for Java with eviction support implemented by
        separate RSetCache object which extends RSet interface. It also
        implements java.util.Set interface.

        Current redis implementation doesn't has set value eviction
        functionality. Therefore expired values are cleaned by
        org.redisson.EvictionScheduler. It removes 100 expired values at once.
        Task launch time tuned automatically and depends on expired entries
        amount deleted in previous time and varies between 1 second to 2 hours.
        Thus if clean task deletes 100 values each time it will be executed
        every second (minimum execution delay). But if current expired values
        amount is lower than previous one then execution delay will be increased
        by 1.5 times.
         ]]>
        
        
            
                
            
        
    
    
    
        
            Map eviction
        
        Redisson distributed Map for Java with eviction support implemented by
        separate RMapCache object which extends RMap interface. It keeps
        elements in insertion order and implements
        java.util.concurrent.ConcurrentMap and java.util.Map interfaces.
        Redisson has a Spring Cache integration which based on Map and MapCache
        objects.

        Current redis implementation doesn't has map entry eviction
        functionality. Therefore expired entries are cleaned by
        org.redisson.EvictionScheduler. It removes 100 expired entries at once.
        Task launch time tuned automatically and depends on expired entries
        amount deleted in previous time and varies between 1 second to 2 hours.
        Thus if clean task deletes 100 entries each time it will be executed
        every second (minimum execution delay). But if current expired entries
        amount is lower than previous one then execution delay will be increased
        by 1.5 times.
         ]]>
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            Map local cache
        
        In case when a Map is used mostly for read operations and/or network
        roundtrips are undesirable. Redisson offers RLocalCachedMap object which
        caches Map entries on Redisson side.
         ]]>
        
        
            
                
                    
                        
                            
                        
                    
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
                    
                        
                            
                        
                        
                            
                        
                    
                
            
        
    
    
    
        
            
        
        
            
                
                    
                        
                            
                        
                    
                
            
        
    
    
    
        
            
        
        
            
                
                    
                        
                            
                        
                    
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
             interface.
        Keeps elements uniqueness via element state comparison.
         ]]>
        
        
            
                
            
        
    
    
    
        
             interface.
        Keeps elements uniqueness via element state comparison.
         ]]>
        
        
            
                
                    
                        
                            
                        
                    
                
            
        
    
    
    
        
             interface.
        Keeps elements uniqueness via element state comparison.
         ]]>
        
        
            
                
                    
                        
                            
                        
                    
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
                    
                        
                            
                        
                    
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        
        
            
                
                    
                        
                            
                        
                    
                
            
        
    
    
    
        
            
        
        
            
                
                    
                        
                            
                            
                        
                    
                    
                        
                            
                        
                    
                
            
        
    
    
    
        
            
        
        
            
                
            
        
    
    
    
        
            
        Live distributed object (also abbreviated as live object) refers to a
        running instance of a distributed multi-party (or peer-to-peer) protocol,
        viewed from the object-oriented perspective, as an entity that has a
        distinct identity, may encapsulate internal state and threads of
        execution, and that exhibits a well-defined externally visible behavior.
        
        
        Redisson Live Object (RLO) realised this idea by mapping all the fields
        inside a Java class to a redis hash through a runtime-constructed proxy
        class. All the get/set methods of each field are translated to hget/hset
        commands operated on the redis hash, making it accessable to/from any
        clients connected to the same redis server. As we all know, the field
        values of an object represent its state; having them stored in a remote
        repository, redis, makes it a distributed object. This object is a
        Redisson Live Object.

        By using RLO, sharing an object between applications and/or servers is
        the same as sharing one in a standalone application. This removes the
        need for serialization and deserialization, and at the same time reduces
        the complexity of the programming model: Changes made to one field
        is (almost^) immediately accessable to other processes, applications and
        servers. (^Redis' eventual consistant replication rule still applies
        when connected to slave nodes)

        Since the redis server is a single-threaded application, all field
        access to the live object is automatically executed in atomic fashion: a
        value will not be changed when you are reading it.

        With RLO, you can treat the redis server as a shared Heap space for all
        connected JVMs.
         ]]>
        
        
            
                
                    
                        
                            
                            
                        
                    
                
            
        
    
    
    
        
            
        
        
            
                
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                    
                        
                            
                        
                    
                
            
        
    
    
    
        
            
        
        
            
                
                    
                        
                    
                
            
        
    
    
    
    
    
        
            
                Define and create a Redisson instance.
            
        
        
            
                
                    
                        
                            
                            
                            
                            
                            
                        
                        
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                        
                    
                
            
        
    

    
        
            
                Define and create a RedisClient instance.