Code Snippets

Space operations with POJO objects can be conducted using the org.openspaces.core.GigaSpace interface or the com.j_spaces.core.IJSpace interface.

The code snippets below use the org.openspaces.core.GigaSpace interface that is the recommended interface.

Write and Read

Write and Read

Getting Space proxy:

UrlSpaceConfigurer urlSpaceConfigurer = new UrlSpaceConfigurer("jini://*/*/mySpace");
GigaSpace space = new GigaSpaceConfigurer(urlSpaceConfigurer.space())
	.defaultTakeTimeout(1000)
 	.defaultReadTimeout(1000)
 	.gigaSpace();

The following writes an Employee object and reads it back using a simple template:

GigaSpace space;
Employee employee = new Employee("Last Name", new Integer(32));
employee.setFirstName("first name");
LeaseContext<Employee> lc = space.write(employee);
Employee template = new Employee();
Employee result = space.read(template);

Notification Registration

Notification Registration

The following registers for notifications:

GigaSpace space;
SimpleNotifyEventListenerContainer
	notifyEventListenerContainer = new SimpleNotifyContainerConfigurer(space)
	.template(new Employee())
	.eventListenerAnnotation(new Object()
		{
		@SpaceDataEvent
		public void eventHappened(Object event) {
		System.out.println("onEvent called Got" + event);
	   	}
	})
	.fifo(true)
	.notifyWrite(true)
	.notifyUpdate(true)
	.notifyContainer();

Batch Write

Batch Write

When writing a batch of objects into the space, these should be placed into an array to be used by the GigaSpace.writeMultiple operation. The returned array will include the corresponding LeaseContext object.

GigaSpace space; 
Employee emps[] = new Employee[2]; 
emps[0] = new Employee("Last Name A", new Integer(10)); 
emps[1] = new Employee("Last Name B", new Integer(20)); 
try { 
    LeaseContext[] leaseContexts = space.writeMultiple(emps); 
    for (int i = 0;i<leaseContexts.length ; i++) { 
        System.out.println ("Object UID " + leaseContexts[i].getUID() + " inserted into the space"); 
    } 
} catch (WriteMultipleException e) { 
    IWriteResult[] writeResult = e.getResults(); 
    for (int i = 0;i< writeResult.length ; i++) { 
        System.out.println ("Problem with Object UID " + writeResult "); 
    } 
}

Batch Read

Batch Read

The following queries the space using SQL:

GigaSpace space;
String querystr	= "age>40";
SQLQuery query = new SQLQuery(Employee.class, querystr);
Employee results[] = space.readMultiple(query , Integer.MAX_VALUE);
Constructing SQLQuery objects is a relatively expensive operation. You should not construct these with every space query operation. Instead, it is recommended to construct it once, and then use it with dynamic query options: SQLQuery.setParameters and SQLQuery.setParameter.

Clear

Clear Objects

You can use the SQLQuery with the GigaSpace.clear to remove objects from the space:

GigaSpace space;
String querystr	= "age>30";
SQLQuery query = new SQLQuery(Employee.class, querystr);
space.clear(query);
When using the SQLQuery with bigger/less than queries, turn on the extended indexing.

Updating an Object

Updating an Object

The GigaSpace.write with the WriteModifiers.UPDATE_ONLY modifier should be used to explicitly perform an update operation. The WriteModifiers.UPDATE_OR_WRITE is the default mode with write operations. This means that subsequent calls to the write operation with an object with identical SpaceId will result in an update operation - i.e. a new object will not be inserted into the space.

Make sure your Space Class will have the SpaceId(autoGenerate=false) when performing update operations.

The GigaSpace.write has a few activity modes - With each mode the return object options are different.:

  1. Inserting or updating an existing object - The WriteModifiers.UPDATE_OR_WRITE modifier should be used. This is the default mode.
  2. Inserting a new object into the space - The WriteModifiers.WRITE_ONLY modifier should be used.
  3. Updating an existing object - The WriteModifiers.UPDATE_ONLY modifier should be used.
  4. Updating an existing object but sending only the modified fields to the space - The WriteModifiers.PARTIAL_UPDATE modifier should be used.
  • when the WriteModifiers.UPDATE_OR_WRITE modifier is applied, the following returns:
    • For a successful operation:
      • LeaseContext - The LeaseContext.getObject() will return:
        • null - if a new object is inserted (write operation)
        • The previous version of the object (update operation)
    • For an unsuccessful operation:
  • when the WriteModifiers.UPDATE_ONLY modifier is applied the following returns:
    • For a successful operation:
      • LeaseContext - Where the LeaseContext.getObject() will return the previous version of the object.
    • For an unsuccessful operation
      • null - if a timeout occurred. This means the object is locked under another transaction.
      • an Exception object is thrown - the options are:
        • EntryNotInSpaceException

          - in case the object does not exist in the space.

        • SpaceOptimisticLockingFailureException

          . Thrown only when running in Optimistic Locking mode. This Exception includes the existing version id of the object within the space and the client side version id of the object. In this case you should read the object again and retry the update operation. See Optimistic Locking for more details.

  • when the WriteModifiers.PARTIAL_UPDATE modifier is applied the return values are the same as with the WriteModifiers.UPDATE_ONLY case. Fields that should not be updated should have the value null. This means that only fields which are set will be sent into the space to replace the existing field's value. Make sure the updated object include its ID when using this option.

When updating an object, you can specify 0 (ZERO) as the lease time. This will instruct the space to use the original lease time used when the object has been written into the space.

UPDATE_OR_WRITE Example:

try
{
	LeaseContext ret = space.write(employee ,/*lease*/  0 ,/*timeout*/  1000 , WriteModifiers.UPDATE_OR_WRITE);
	if ( ret.getObject() == null)
	{
		//  successful write
	}
	if (ret.getObject() instanceof Employee)
	{
		//  successful update
	}
}
catch (UpdateOperationTimeoutException uote)
{
	// Object is locked - unsuccessful update
}

WRITE_ONLY Example:

try
{
	LeaseContext ret = space.write(employee ,/*lease*/  0 ,/*timeout*/  1000 , WriteModifiers.WRITE_ONLY);
	if ( ret.getObject() == null)
	{
		//  successful write
	}
}
catch (EntryAlreadyInSpaceException eainse)
{
	// Object already exists - unsuccessful write
}

UPDATE_ONLY Example:

try
{
	LeaseContext ret = space.write(employee ,/*lease*/  0 ,/*timeout*/  1000 , WriteModifiers.UPDATE_ONLY);
	if ( ret == null)
	{
		// Object is locked - unsuccessful update
	}
	else if (ret.getObject() instanceof Employee)
	{
		//  successful update
	}
}
catch (EntryNotInSpaceException enise)
{
	// Object not in space - unsuccessful update
}
catch (SpaceOptimisticLockingFailureException solfe)
{
	// Client holds wrong version of the object - unsuccessful update. We need to read it again and issue the update call again.
}

PARTIAL_UPDATE Example:

GigaSpace space = new GigaSpaceConfigurer (new UrlSpaceConfigurer("jini://*/*/mySpace").noWriteLease(true)).gigaSpace();

// initial insert
MyClass obj = new MyClass();
obj.setId("1");
obj.setField1("A");
obj.setField2("B");
obj.setField3("C");                               
space.write(obj);

// reading object back from the space
MyClass obj2 = space.readById(MyClass.class , "1");

// updating only field2 
obj2.setField1(null);
obj2.setField2("BBBB");
obj2.setField3(null);
try
{
	space.write(obj2,0,0,WriteModifiers.PARTIAL_UPDATE);
}
catch (EntryNotInSpaceException enise)
{
	// Object not in space - unsuccessful update
}

Batch Update

Batch Update

Make sure your Space Class will have the SpaceId(autoGenerate=false) when performing update operations.

The GigaSpace.updateMultiple returns an array of objects which correspond to the input object array. The returned object element can be one of the following:

  • when the WriteModifiers.UPDATE_OR_WRITE modifier is applied the following returns:
    • For a successful operation:
      • null - if a new object is inserted (write operation)
      • The previous version of the object (update operation)
        Since the GigaSpace.updateMultiple in WriteModifiers.UPDATE_OR_WRITE

        mode does not support timeout based updates, there is no way to identify if an updated object is already locked under a transaction - i.e. the
        UpdateOperationTimeoutException is not returned as part of the returned array elements.
        With a transactional system, it is recommended to perform batch updates using the WriteModifiers.UPDATE_ONLY
        modifier.

        UPDATE_ONLY Example:

        GigaSpace space;
        Employee employees[] = space.readMultiple(query , 10000);
        	Object retUpdateMulti[] = space.updateMultiple(employees ,/*leases*/ new long[results.length],WriteModifiers.UPDATE_ONLY);
        
        for (int i = 0;i<retUpdateMulti ; i++)
        {
        	if  (retUpdateMulti[i] == null ) {
        		//  unsuccessful update
        		break;
        	}
        	else if  (retUpdateMulti[i] instanceof Exception) {
        		//  unsuccessful update
        		if (retUpdateMulti[i] instanceof EntryNotInSpaceException)
        		{
        		...
        		}
        
        		else if (retUpdateMulti[i] instanceof SpaceOptimisticLockingFailureException)
        		{
        		...
        		}
        
        
        		break;
        	}
        
        	else if  (retUpdateMulti[i] instanceof Employee ) {
        		//  successful update
        	}
        }

        PARTIAL_UPDATE Example:

        GigaSpace space;
        for (int i=0;i<employees.length;i++)
        {
        	employees[i].setFirstName(null);
        	employees[i].setLastName(null);
        	employees[i].setBalance(newValue);
        	leases[i] = Lease.FOREVER;
        }
        
        space.writeMultiple(employees, Lease.FOREVER, WriteModifiers.PARTIAL_UPDATE);
GigaSpaces.com - Legal Notice - 3rd Party Licenses - Site Map - API Docs - Forum - Downloads - Blog - White Papers - Contact Tech Writing - Gen. by Atlassian Confluence