Basic Object Retrieval¶
Backendless supports multiple data search and retrieval operations. These include finding an object by its objectId
, finding first or last object in the collection or retrieving the entire persisted collection. Each method is available in both blocking and non-blocking formats:
Retrieving Data Objects¶
Blocking API¶
Retrieve data objects with the default paging setting from a table:
public List<Map> Backendless.Data.of( "TABLE-NAME" ).find()
public Map Backendless.Data.of( "TABLE-NAME" ).findFirst()
public Map Backendless.Data.of( "TABLE-NAME" ).findLast()
public Map Backendless.Data.of( "TABLE-NAME" ).findById( String objectId )
Retrieve data objects with the default paging setting from a table. Returned collection will contain objects of type E (the name of the class must match the name of the table):
public List<E> Backendless.Data.of( E ).find()
public E Backendless.Data.of( E ).findFirst()
public E Backendless.Data.of( E ).findLast()
public E Backendless.Data.of( E ).findById( String objectId )
Non-Blocking API¶
Retrieve data objects with the default paging setting from a table:
public void Backendless.Data.of( "TABLE-NAME" ).find( AsyncCallback<List<Map>> responder )
public void Backendless.Data.of( "TABLE-NAME" ).findFirst( AsyncCallback<Map> responder )
public void Backendless.Data.of( "TABLE-NAME" ).findLast( AsyncCallback<Map> responder )
public void Backendless.Data.of( "TABLE-NAME" ).findById( String objectId,
AsyncCallback<Map> responder )
Retrieve data objects with the default paging setting from a table. Returned collection will contain objects of type E (the name of the class must match the name of the table):
public void Backendless.Persistence.of( E ).find( AsyncCallback<List<E>> responder );
public void Backendless.Persistence.of( E ).findFirst( AsyncCallback<E> responder )
public void Backendless.Persistence.of( E ).findLast( AsyncCallback<E> responder )
public void Backendless.Persistence.of( E ).findById( String objectId,
AsyncCallback<E> responder )
where:
Argument | Description |
---|---|
TABLE-NAME |
Name of the table from where the data is retrieved from. |
E |
Java class identifying the table where from where the data must be loaded from. For example, if the table is "Person ", the argument should Person.class . |
responder |
a responder object which will receive a callback when the method successfully returns a result or an error. Applies to the asynchronous methods only. |
Example¶
The following code demonstrates various search queries:
Load contacts using default paging¶
**Blocking API**
``` java
List<Map> result = Backendless.Data.of( "Contact" ).find();
```
**Non-Blocking API**
``` java
Backendless.Data.of( "Contact" ).find( new AsyncCallback<List<Map>>(){
@Override
public void handleResponse( List<Map> foundContacts )
{
// every loaded object from the "Contact" table is now an individual java.util.Map
}
@Override
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be retrieved with fault.getCode()
}
});
```
Find first contact¶
**Blocking API**
``` java
Map firstContact = Backendless.Data.of( "Contact" ).findFirst();
```
**Non-Blocking API**
``` java
Backendless.Data.of( "Contact" ).findFirst( new AsyncCallback<Map>(){
@Override
public void handleResponse( Map contact )
{
// first contact instance has been found
}
@Override
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be retrieved with fault.getCode()
}
});
```
Find last contact¶
**Blocking API**
``` java
Map firstContact = Backendless.Data.of( "Contact" ).findLast();
```
**Non-Blocking API**
``` java
Backendless.Data.of( "Contact" ).findLast( new AsyncCallback<Map>(){
@Override
public void handleResponse( Map contact )
{
// last contact instance has been found
}
@Override
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be retrieved with fault.getCode()
}
});
```
Find contact by objectId¶
**Blocking API**
``` java
// Save a contact object first. Once it is saved, we will retrieve it by assigned objectId
HashMap contact = new HashMap();
contact.put( "name", "Jack Daniels" );
contact.put( "age", 147 );
contact.put( "phone", "777-777-777" );
contact.put( "title", "Favorites" );
// save object synchronously
Map savedContact = Backendless.Data.of( "Contact" ).save( contact );
// now retrieve the object using it's objectId
Map lastContact = Backendless.Data.of( "Contact" ).
findById( savedContact.get( "objectId" ) );
```
**Non-Blocking API**
``` java
// Save a contact object first. Once it is saved, we will retrieve it by assigned objectId
HashMap contact = new HashMap();
contact.put( "name", "Jack Daniels" );
contact.put( "age", 147 );
contact.put( "phone", "777-777-777" );
contact.put( "title", "Favorites" );
Backendless.Data.of( "Contact" ).save( contact, new AsyncCallback<Map>()
{
@Override
public void handleResponse( Map savedContact )
{
// now that the object is saved and has objectId, retrieve it using "findById"
Backendless.Data.of( Contact.class ).findById( savedContact.get( "objectId" ),
new AsyncCallback<Map>() {
@Override
public void handleResponse( Map response )
{
// an object from the "Contact" table has been found by it's objectId
}
@Override
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be retrieved with fault.getCode()
}
} );
}
@Override
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be retrieved with fault.getCode()
}
} );
```
Consider the following class:
package com.sample;
public class Contact
{
private String objectId;
private String name;
private int age;
private String phone;
private String title;
public String getObjectId() {
return objectId;
}
public void setObjectId( String objectId ) {
this.objectId = objectId;
}
public String getName() {
return name;
}
public void setName( String name ) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge( int age ) {
this.age = age;
}
public String getPhone() {
return phone;
}
public void setPhone( String phone ) {
this.phone = phone;
}
public String getTitle() {
return title;
}
public void setTitle( String title ) {
this.title = title;
}
}
Load contacts using default paging¶
**Blocking API**
``` java
List<Contact> result = Backendless.Data.of( Contact.class ).find();
```
**Non-Blocking API**
``` java
Backendless.Data.of( Contact.class).find( new AsyncCallback<List<Contact>>(){
@Override
public void handleResponse( List<Contact> foundContacts )
{
// all Contact instances have been found
}
@Override
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be retrieved with fault.getCode()
}
});
```
Find first contact¶
**Blocking API**
``` java
Contact firstContact = Backendless.Data.of( Contact.class ).findFirst();
```
**Non-Blocking API**
``` java
Backendless.Data.of( Contact.class).findFirst( new AsyncCallback<Contact>(){
@Override
public void handleResponse( Contact contact )
{
// first contact instance has been found
}
@Override
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be retrieved with fault.getCode()
}
});
```
Find last contact¶
**Blocking API**
``` java
Contact lastContact = Backendless.Data.of( Contact.class ).findLast();
```
**Non-Blocking API**
``` java
Backendless.Data.of( Contact.class).findLast( new AsyncCallback<Contact>(){
@Override
public void handleResponse( Contact contact )
{
// last contact instance has been found
}
@Override
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be retrieved with fault.getCode()
}
});
```
Find contact by objectId¶
**Blocking API**
``` java
// Save a contact object first. Once it is saved, we will retrieve it by assigned objectId
Contact contact = new Contact();
contact.setName( "Jack Daniels" );
contact.setAge( 147 );
contact.setPhone( "777-777-777" );
contact.setTitle( "Favorites" );
// save object synchronously
Contact savedContact = Backendless.Data.save( contact );
// now retrieve the object using it's objectId
Contact foundContact = Backendless.Data.of( Contact.class ).findById( savedContact.getObjectId() );
```
**Non-Blocking API**
``` java
// Save a contact object first. Once it is saved, we will retrieve it by assigned objectId
Contact contact = new Contact();
contact.setName( "Jack Daniels" );
contact.setAge( 147 );
contact.setPhone( "777-777-777" );
contact.setTitle( "Favorites" );
Backendless.Data.save( contact, new AsyncCallback<Contact>()
{
@Override
public void handleResponse( Contact savedContact )
{
// now that the object is saved and has objectId, retrieve it using "findById"
Backendless.Persistence.of( Contact.class ).findById( savedContact.getObjectId(),
new AsyncCallback<Contact>() {
@Override
public void handleResponse( Contact response )
{
// a Contact instance has been found by objectId
}
@Override
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be retrieved with fault.getCode()
}
} );
}
@Override
public void handleFault( BackendlessFault fault )
{
// an error has occurred, the error code can be retrieved with fault.getCode()
}
} );
```