RedissonLiveObjectService (Redisson 2.10.2 API)

java.lang.Object
- org.redisson.RedissonLiveObjectService

All Implemented Interfaces:: RLiveObjectService

public class RedissonLiveObjectService
extends Object
implements RLiveObjectService

Constructor Summary

Constructors
Constructor and Description
`RedissonLiveObjectService(RedissonClient redisson, ConcurrentMap<Class<?>,Class<?>> classCache, CodecProvider codecProvider, ResolverProvider resolverProvider)`

Method Summary

Methods
Modifier and Type	Method and Description
`<T> RLiveObject`	`asLiveObject(T instance)` To cast the instance to RLiveObject instance.
`<T> RExpirable`	`asRExpirable(T instance)` To cast the instance to RExpirable instance.
`<T,K,V> RMap<K,V>`	`asRMap(T instance)` To cast the instance to RMap instance.
`<T> T`	`attach(T detachedObject)` Returns proxied object for the detached object.
`<T,K> void`	`delete(Class<T> entityClass, K id)` Deletes object by class and id including all nested objects.
`<T> void`	`delete(T attachedObject)` Deletes attached object including all nested objects.
`<T> T`	`detach(T attachedObject)` Returns unproxied detached object for the attached object.
`<T,K> T`	`get(Class<T> entityClass, K id)` Finds the entity from Redis with the id.
`RMap<String,Object>`	`getMap(Object proxied)`
`boolean`	`isClassRegistered(Class cls)` Check if the class is registered in the cache.
`<T> boolean`	`isExists(T instance)` Returns true if the RLiveObject does not yet exist in redis.
`<T> boolean`	`isLiveObject(T instance)` Returns true if the instance is a instance of RLiveObject.
`<T> T`	`merge(T detachedObject)` Returns proxied object for the detached object.
`<T> T`	`persist(T detachedObject)` Returns proxied attached object for the detached object.
`void`	`registerClass(Class cls)` Pre register the class with the service, registering all the classes on startup can speed up the instance creation.
`void`	`unregisterClass(Class cls)` Unregister the class with the service.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RedissonLiveObjectService
```
public RedissonLiveObjectService(RedissonClient redisson,
                         ConcurrentMap<Class<?>,Class<?>> classCache,
                         CodecProvider codecProvider,
                         ResolverProvider resolverProvider)
```
- Method Detail
  - getMap
```
public RMap<String,Object> getMap(Object proxied)
```
  - get
```
public <T,K> T get(Class<T> entityClass,
          K id)
```
    Description copied from interface: RLiveObjectService
    Finds the entity from Redis with the id. The entityClass should have a field annotated with RId, and the entityClass itself should have REntity annotated. The type of the RId can be anything except the followings:
    1. An array i.e. byte[], int[], Integer[], etc.
    2. or a RObject i.e. RedissonMap
    3. or a Class with REntity annotation.
    Specified by:
    
    get in interface RLiveObjectService
    
    Type Parameters:
    T - Entity type
    K - Key type
    Parameters:
    entityClass - Entity class
    id - identifier
    
    Returns:
    a proxied object if it exists in redis, or null if not.
  - attach
```
public <T> T attach(T detachedObject)
```
    Description copied from interface: RLiveObjectService
    
    Returns proxied object for the detached object. Discard all the field values already in the detached instance. The class representing this object should have a field annotated with RId, and the object should hold a non null value in that field. If this object is not in redis then a new blank proxied instance with the same RId field value will be created.
    
    Specified by:
    
    attach in interface RLiveObjectService
    
    Type Parameters:
    T - Entity type
    Parameters:
    detachedObject - - not proxied object
    
    Returns:
    proxied object
  - merge
```
public <T> T merge(T detachedObject)
```
    Description copied from interface: RLiveObjectService
    
    Returns proxied object for the detached object. Transfers all the NON NULL field values to the redis server. It does not delete any existing data in redis in case of the field value is null. The class representing this object should have a field annotated with RId, and the object should hold a non null value in that field. If this object is not in redis then a new hash key will be created to store it.
    
    Specified by:
    
    merge in interface RLiveObjectService
    
    Type Parameters:
    T - Entity type
    Parameters:
    detachedObject - - not proxied object
    
    Returns:
    proxied object
  - persist
```
public <T> T persist(T detachedObject)
```
    Description copied from interface: RLiveObjectService
    
    Returns proxied attached object for the detached object. Transfers all the NON NULL field values to the redis server. Only when the it does not already exist. If this object is not in redis then a new hash key will be created to store it.
    
    Specified by:
    
    persist in interface RLiveObjectService
    
    Type Parameters:
    T - Entity type
    Parameters:
    detachedObject - - not proxied object
    
    Returns:
    proxied object
  - detach
```
public <T> T detach(T attachedObject)
```
    Description copied from interface: RLiveObjectService
    
    Returns unproxied detached object for the attached object.
    
    Specified by:
    
    detach in interface RLiveObjectService
    
    Type Parameters:
    T - Entity type
    Parameters:
    attachedObject - - proxied object
    
    Returns:
    proxied object
  - delete
```
public <T> void delete(T attachedObject)
```
    Description copied from interface: RLiveObjectService
    
    Deletes attached object including all nested objects.
    
    Specified by:
    
    delete in interface RLiveObjectService
    
    Type Parameters:
    T - Entity type
    Parameters:
    attachedObject - - proxied object
  - delete
```
public <T,K> void delete(Class<T> entityClass,
                K id)
```
    Description copied from interface: RLiveObjectService
    
    Deletes object by class and id including all nested objects.
    
    Specified by:
    
    delete in interface RLiveObjectService
    
    Type Parameters:
    T - Entity type
    K - Key type
    Parameters:
    entityClass - - object class
    id - - object id
  - asLiveObject
```
public <T> RLiveObject asLiveObject(T instance)
```
    Description copied from interface: RLiveObjectService
    
    To cast the instance to RLiveObject instance.
    
    Specified by:
    
    asLiveObject in interface RLiveObjectService
    
    Type Parameters:
    T - type of instance
    Parameters:
    instance - - live object
    
    Returns:
    RLiveObject compatible object
  - asRExpirable
```
public <T> RExpirable asRExpirable(T instance)
```
    Description copied from interface: RLiveObjectService
    
    To cast the instance to RExpirable instance.
    
    Specified by:
    
    asRExpirable in interface RLiveObjectService
    
    Type Parameters:
    T - type of instance
    Parameters:
    instance - - live object
    
    Returns:
    RExpirable compatible object
  - asRMap
```
public <T,K,V> RMap<K,V> asRMap(T instance)
```
    Description copied from interface: RLiveObjectService
    
    To cast the instance to RMap instance.
    
    Specified by:
    
    asRMap in interface RLiveObjectService
    
    Type Parameters:
    T - type of instance
    K - type of key
    V - type of value
    Parameters:
    instance - - live object
    
    Returns:
    RMap compatible object
  - isLiveObject
```
public <T> boolean isLiveObject(T instance)
```
    Description copied from interface: RLiveObjectService
    
    Returns true if the instance is a instance of RLiveObject.
    
    Specified by:
    
    isLiveObject in interface RLiveObjectService
    
    Type Parameters:
    T - type of instance
    Parameters:
    instance - - live object
    
    Returns:
    true object is RLiveObject
  - isExists
```
public <T> boolean isExists(T instance)
```
    Description copied from interface: RLiveObjectService
    
    Returns true if the RLiveObject does not yet exist in redis. Also true if the passed object is not a RLiveObject.
    
    Specified by:
    
    isExists in interface RLiveObjectService
    
    Type Parameters:
    T - type of instance
    Parameters:
    instance - - live object
    
    Returns:
    true object exists
  - registerClass
```
public void registerClass(Class cls)
```
    Description copied from interface: RLiveObjectService
    
    Pre register the class with the service, registering all the classes on startup can speed up the instance creation. This is 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.
    
    Specified by:
    
    registerClass in interface RLiveObjectService
    
    Parameters:
    cls - - class
  - unregisterClass
```
public void unregisterClass(Class cls)
```
    Description copied from interface: RLiveObjectService
    
    Unregister the class with the service. This is useful after you decide the class is no longer required. A class will be automatically unregistered if the service encountered any errors during proxying or creating the object, since those errors are not recoverable. 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.
    
    Specified by:
    
    unregisterClass in interface RLiveObjectService
    
    Parameters:
    cls - It can be either the proxied class or the unproxied conterpart.
  - isClassRegistered
```
public boolean isClassRegistered(Class cls)
```
    Description copied from interface: RLiveObjectService
    
    Check if the class is registered in the cache. 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.
    
    Specified by:
    
    isClassRegistered in interface RLiveObjectService
    
    Parameters:
    cls - - type of instance
    
    Returns:
    true if class already registered

Class RedissonLiveObjectService

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RedissonLiveObjectService

Method Detail

getMap

get

attach

merge

persist

detach

delete

delete

asLiveObject

asRExpirable

asRMap

isLiveObject

isExists

registerClass

unregisterClass

isClassRegistered