RLiveObjectService (Redisson 3.11.6 API)

All Known Implementing Classes:

RedissonLiveObjectService
```
public interface RLiveObjectService
```
The pre-registration of each entity class is not necessary. Entity's getters and setters operations gets redirected to Redis automatically.

Author:

Rui Gu (https://github.com/jackygurui), Nikita Koksharov

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`<T> RLiveObject`	`asLiveObject(T instance)` To cast the instance to RLiveObject instance.
`<T> RExpirable`	`asRExpirable(T instance)` Deprecated.
`<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> boolean`	`delete(Class<T> entityClass, Object 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> Collection<T>`	`find(Class<T> entityClass, Condition condition)` Finds the entities matches specified `condition`.
`<T> T`	`get(Class<T> entityClass, Object id)` Finds the entity from Redis with the id.
`boolean`	`isClassRegistered(Class<?> cls)` Check if the class is registered in the cache.
`<T> boolean`	`isExists(T instance)` Returns true if the RLiveObject already exists 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> List<T>`	`persist(T... detachedObjects)` Returns proxied attached objects for the detached objects.
`<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.

- Method Detail
  - get
```
<T> T get(Class<T> entityClass,
          Object id)
```
    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.
    Type Parameters:
    
    T - Entity type
    
    Parameters:
    
    entityClass - - entity class
    
    id - identifier
    
    Returns:
    
    a proxied object if it exists in redis, or null if not.
  - find
```
<T> Collection<T> find(Class<T> entityClass,
                       Condition condition)
```
    Finds the entities matches specified condition. Usage example:
```
 Collection objects = liveObjectService.find(MyObject.class, Conditions.or(Conditions.in("field", "value1", "value2"), 
                          Conditions.and(Conditions.eq("field2", "value2"), Conditions.eq("field3", "value5"))));
 
```
    Type Parameters:
    
    T - Entity type
    
    Parameters:
    
    entityClass - - entity class
    
    condition - - condition object
    
    Returns:
    
    collection of live objects or empty collection.
    
    See Also:
    
    Conditions
  - attach
```
<T> T attach(T detachedObject)
```
    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.
    
    Type Parameters:
    
    T - Entity type
    
    Parameters:
    
    detachedObject - - not proxied object
    
    Returns:
    
    proxied object
    
    Throws:
    
    IllegalArgumentException - if the object is is a RLiveObject instance.
  - merge
```
<T> T merge(T detachedObject)
```
    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.
    
    Type Parameters:
    
    T - Entity type
    
    Parameters:
    
    detachedObject - - not proxied object
    
    Returns:
    
    proxied object
    
    Throws:
    
    IllegalArgumentException - if the object is is a RLiveObject instance.
  - persist
```
<T> T persist(T detachedObject)
```
    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.
    
    Type Parameters:
    
    T - Entity type
    
    Parameters:
    
    detachedObject - - not proxied object
    
    Returns:
    
    proxied object
  - persist
```
<T> List<T> persist(T... detachedObjects)
```
    Returns proxied attached objects for the detached objects. Stores all the NON NULL field values.
    
    Type Parameters:
    
    T - Entity type
    
    Parameters:
    
    detachedObjects - - not proxied objects
    
    Returns:
    
    list of proxied objects
  - detach
```
<T> T detach(T attachedObject)
```
    Returns unproxied detached object for the attached object.
    
    Type Parameters:
    
    T - Entity type
    
    Parameters:
    
    attachedObject - - proxied object
    
    Returns:
    
    proxied object
  - delete
```
<T> void delete(T attachedObject)
```
    Deletes attached object including all nested objects.
    
    Type Parameters:
    
    T - Entity type
    
    Parameters:
    
    attachedObject - - proxied object
  - delete
```
<T> boolean delete(Class<T> entityClass,
                   Object id)
```
    Deletes object by class and id including all nested objects.
    
    Type Parameters:
    
    T - Entity type
    
    Parameters:
    
    entityClass - - object class
    
    id - - object id
    
    Returns:
    
    true if entity was deleted successfully, false otherwise
  - asLiveObject
```
<T> RLiveObject asLiveObject(T instance)
```
    To cast the instance to RLiveObject instance.
    
    Type Parameters:
    
    T - type of instance
    
    Parameters:
    
    instance - - live object
    
    Returns:
    
    RLiveObject compatible object
  - asRExpirable
```
@Deprecated
<T> RExpirable asRExpirable(T instance)
```
    Deprecated.
    
    Use asRMap(Object) method instead
  - asRMap
```
<T,K,V> RMap<K,V> asRMap(T instance)
```
    To cast the instance to RMap instance.
    
    Type Parameters:
    
    T - type of instance
    
    K - type of key
    
    V - type of value
    
    Parameters:
    
    instance - - live object
    
    Returns:
    
    RMap compatible object
  - isLiveObject
```
<T> boolean isLiveObject(T instance)
```
    Returns true if the instance is a instance of RLiveObject.
    
    Type Parameters:
    
    T - type of instance
    
    Parameters:
    
    instance - - live object
    
    Returns:
    
    true object is RLiveObject
  - isExists
```
<T> boolean isExists(T instance)
```
    Returns true if the RLiveObject already exists in redis. It will return false if the passed object is not a RLiveObject.
    
    Type Parameters:
    
    T - type of instance
    
    Parameters:
    
    instance - - live object
    
    Returns:
    
    true object exists
  - registerClass
```
void registerClass(Class<?> cls)
```
    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.
    
    Parameters:
    
    cls - - class
  - unregisterClass
```
void unregisterClass(Class<?> cls)
```
    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.
    
    Parameters:
    
    cls - It can be either the proxied class or the unproxied conterpart.
  - isClassRegistered
```
boolean isClassRegistered(Class<?> cls)
```
    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.
    
    Parameters:
    
    cls - - type of instance
    
    Returns:
    
    true if class already registered

Interface RLiveObjectService

Method Summary

Method Detail

get

find

attach

merge

persist

persist

detach

delete

delete

asLiveObject

asRExpirable

asRMap

isLiveObject

isExists

registerClass

unregisterClass

isClassRegistered