JDX Programming Code Snippets

Mapping JSON Objects


This snippet shows how to define classes and mapping specifications for persisting JSON objects in a database using JDX ORM. It also shows JDX ORM programming code of how JSON objects can easily be inserted, deleted, updated, and retrieved in an intuitive object oriented way.

Although this snippet shows how JDX can help you with persistence of simple JSON objects, JDX can also help you easily handle complex JSON objects having other nested JSON objects and arrays of JSON objects.

Class Definitions

                
                

                 
    
                    
  1. import org.json.JSONException;
    2. 
                    
  2. import org.json.JSONObject;
    3. 
                    
  3.  
    4. 
                    
  4. import com.softwaretree.jdxandroid.JDX_JSONObject;
    5. 
                    
  5.  
    6. 
                    
  6. public class JSON_Employee extends JDX_JSONObject {
    7. 
                    
  7.  
    8. 
                    
  8.     public JSON_Employee() {
    9. 
                    
  9.      super();
    10. 
                    
  10.     }
    11. 
                    
  11.  
    12. 
                    
  12.     public JSON_Employee(JSONObject jsonObject) throws JSONException {
    13. 
                    
  13.      super(jsonObject);
    14. 
                    
  14.     }
    15. 
                    
  15. }
    16.
Notes:
  • JSON_Employee is a simple shell class defining a domain model object class for Employee objects based on the JSONObject class.
    (line 6)
  • The JDX_JSONObject class serves as a base class for persisting JSONObject instances of a domain specific class (JSON_Employee), which is defined as a subclass of this class.
    (line 6)
  • This class needs to define just two constructors. Most of the processing is handled by the superclass JDX_JSONObject.
    (lines 8 and 12)

Mapping Specification

           
           

           
    
            
  1. CLASS com.softwaretree.jdxandroidjsonexample.model.JSON_Employee TABLE Employee
    2. 
            
  2.     VIRTUAL_ATTRIB id ATTRIB_TYPE int
    3. 
            
  3.     VIRTUAL_ATTRIB name ATTRIB_TYPE java.lang.String
    4. 
            
  4.     VIRTUAL_ATTRIB exempt ATTRIB_TYPE boolean
    5. 
            
  5.     VIRTUAL_ATTRIB compensation ATTRIB_TYPE double
    6. 
            
  6.     VIRTUAL_ATTRIB DOB ATTRIB_TYPE long
    7. 
            
  7.  
    8. 
            
  8.     PRIMARY_KEY id
    9. 
            
  9.     SQLMAP FOR compensation COLUMN_NAME salary
    10. 
            
  10. ;
    11.
Notes:
  • A VIRTUAL_ATTRIB specification is used to identify each persistent attribute of the corresponding JSON object (i.e., id, name, exempt, compensation, and DOB of an employee).
    (lines 2 to 6)
  • A date is represented as long (number of milliseconds) for a JSON object since there is no standard JSON string format for date representation.
    (line 6)
  • Rest of the mapping specification is provided after all the VIRTUAL_ATTRIB specifications.
    (lines 8 to 9)

Programming Example 

                
                

                  
    
                    
  1. // Assuming jdxSetup of type JDXSetup has already been initialized.
    2. 
                    
  2.  
    3. 
                    
  3. // Obtain ORM handles.
    4. 
                    
  4. JXResource jxResource = jdxSetup.checkoutJXResource();v
                    
  5. JXSession jxSessionHandle = jxResource.getJXSessionHandle();
    6. 
                    
  6. JDXS jdxHandle = jxResource.getJDXHandle();
    7. 
                    
  7.  
    8. 
                    
  8. String employeeClassName = JSON_Employee.class.getName();
    9. 
                    
  9. DateFormat dfm = new SimpleDateFormat("yyyy-MM-dd");
    10. 
                    
  10. dfm.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
    11. 
                    
  11. 
                    
  12. try {
    13. 
                    
  13.       // First delete all existing employees from the database.
    14. 
                    
  14.       jdxHandle.delete2(employeeClassName, null, 0);
    15. 
                    
  15.  
    16. 
                    
  16.       // Create and save a new JSON employee object, Mark.
    17. 
                    
  17.       JSON_Employee emp = new JSON_Employee();
    18. 
                    
  18.       emp.put("id", 1);
    19. 
                    
  19.       emp.put("name", "Mark");
    20. 
                    
  20.       emp.put("exempt", true);
    21. 
                    
  21.       emp.put("compensation", 51001.0);
    22. 
                    
  22.       emp.put("DOB", dfm.parse("1981-01-01").getTime());
    23. 
                    
  23.  
    24. 
                    
  24.       jdxHandle.insert(emp, 0, null);
    25. 
                    
  25.  
    26. 
                    
  26.       // Create and save a new JSON employee object, David, using an
      explicit JSONObject instance.
    27. 
                    
  27.       JSONObject jsonObject = new JSONObject();
    28. 
                    
  28.       jsonObject.put("id", 2);
    29. 
                    
  29.       jsonObject.put("name", "David");
    30. 
                    
  30.       jsonObject.put("exempt", true);
    31. 
                    
  31.       jsonObject.put("compensation", 52002.0);
    32. 
                    
  32.       jsonObject.put("DOB", dfm.parse("1982-02-02").getTime());
    33. 
                    
  33.       emp = new JSON_Employee(jsonObject);
    34. 
                    
  34.  
    35. 
                    
  35.       jdxHandle.insert(emp, 0, null);
    36. 
                    
  36.  
    37. 
                    
  37.       // Create and save a new JSON employee, Steve, using an alternate way by
      employing a JSON string.
    38. 
                    
  38.       // The JSON object string may come from another source, for example a web service.
    39. 
                    
  39.       String dob = new Long(dfm.parse("1983-03-03").getTime()) .toString();
    40. 
                    
  40.       String jsonString = "{\"id\": 3, \"name\": \"Steve\", \"DOB\":" + dob +
      "," + "\"exempt\": false,\"compensation\": 53003.0}";
    41. 
                    
  41.       jsonObject = new JSONObject(jsonString);
    42. 
                    
  42.       emp = new JSON_Employee(jsonObject);
    43. 
                    
  43.  
    44. 
                    
  44.       jdxHandle.insert(emp, 0, null);
    45. 
                    
  45.  
    46. 
                    
  46.       // Retrieve all the employees
    47. 
                    
  47.       List queryResults = jdxHandle.query(employeeClassName, null,
                          JDXS.ALL, JDXS.FLAG_SHALLOW, null);
    48. 
                    
  48.  
    49. 
                    
  49.       // Retrieve employee, David (id=2)
    50. 
                    
  50.       ObjectId oid = ObjectId.createObjectId(employeeClassName +"; id=2");
    51. 
                    
  51.       emp = (JSON_Employee) jdxHandle.getObjectById(oid, false,
             JDXS.FLAG_SHALLOW, null);
    52. 
                    
  52.  
    53. 
                    
  53.       // Get the underlying JSONObject instance from the Employee object 
    54. 
                    
  54.       retrieved from the database
    55. 
                    
  55.       jsonObject = emp.getJSONObject();
    56. 
                    
  56. } catch (Exception ex) {
    57. 
                    
  57.       Log.e("JDX", "Error" ex);
    58. 
                    
  58.       throw ex;
    59. 
                    
  59. } finally {
    60. 
                    
  60.       jdxSetup.checkinJXResource(jxResource);
    61. 
                    
  61. }
    62.
Notes:
  • All the notes of the Simple Mapping 1 Example apply.
  • Whereas the Simple Mapping Example 1 uses a higher-level façade (JDXHelper) to interact with the JDX ORM system, this code snippet uses JXResource, JXSession, and JDXS objects to interact more directly with the ORM system.
    (lines 4, 5, 6)
  • As various comments in the above programming code suggest, JSON objects may be created and obtained in many different ways.
    (lines 17, 27, 41, 54)
Previous
Next