Core Data with Mantle

Mantle makes it easy to write a simple model layer for your Cocoa or Cocoa Touch application. Mantle can still be a convenient translation layer between the API and your managed model objects.

This article uses mantle as a data model and uses it to create a data persistence process for the coredata interface.

The operation process is simple, that is, data conversion:

1. Manle data model

The method used for persistence in Mantle:

// A MTLModel object that supports being serialized to and from Core Data as

// NSManagedObject.

• @ Protocol MTLManagedObjectSerializing
• @ Required

  // The name of the Core Data entity that the specified er serializes to and

  // Deserializes from.

  • + (NSString *) managedObjectEntityName;

    // Specifies how to map property keys to different keys on the specified er's

    // + ManagedObjectEntity.

    • + (NSDictionary *) managedObjectKeysByPropertyKey;
      

      . H file

      [Objc]View plaincopyprint?
      1. # Import
      3. @ Interface BannerWrapper: MTLModel
      5. @ Property (nonatomic, readonly) bool result;
      6. @ Property (copy, nonatomic, readonly) NSNumber * resultId;
      7. @ Property (copy, nonatomic, readonly) NSString * resultMsg;
      8. @ Property (copy, nonatomic) NSArray * bannerList;
      9. + (NSSortDescriptor *) sortDescriptor;
      10. @ End
      12. @ Interface Banner: MTLModel
      14. @ Property (copy, nonatomic, readonly) NSNumber * bannerId;
      15. @ Property (copy, nonatomic, readonly) NSString * picUrl;
      16. @ Property (copy, nonatomic, readonly) NSString * toDetailUrl;
      17. @ Property (copy, nonatomic, readonly) NSNumber * width;
      18. @ Property (copy, nonatomic, readonly) NSNumber * height;
      20. @ End
          
          

          . M file

          [Objc]View plaincopyprint?
          1. # Import "Banner. h"
          3. @ Implementation BannerWrapper
          5. # Pragma mark-JSON serialization
          7. + (NSDictionary *) JSONKeyPathsByPropertyKey {
          8. Return @{
          9. @ "Result": @ "result ",
          10. @ "ResultId": @ "resultId ",
          11. @ "ResultMsg": @ "resultMSG ",
          12. @ "BannerList": @ "banner"
          13. };
          14. }
          16. + (NSValueTransformer *) bannerListJSONTransformer
          17. {
          18. Return [NSValueTransformer mtl_JSONArrayTransformerWithModelClass: [Banner class];
          19. }
          21. # Pragma mark-Managed object serialization
          23. + (NSString *) managedObjectEntityName {
          24. Return @ "BannerWrapper ";
          25. }
          27. + (NSDictionary *) managedObjectKeysByPropertyKey {
          28. Return nil;
          29. }
          31. + (NSDictionary *) relationshipModelClassesByPropertyKey {
          32. Return @{
          33. @ "BannerList": [Banner class],
          34. };
          35. }
          37. // Data sorting method when retrieving data from coredata
          38. + (NSSortDescriptor *) sortDescriptor {
          39. Return [[NSSortDescriptor alloc] initWithKey: @ "resultId" ascending: YES];
          40. }
          42. @ End
          44. @ Implementation Banner
          46. # Pragma mark-JSON serialization
          48. + (NSDictionary *) JSONKeyPathsByPropertyKey {
          49. Return @{
          50. @ "BannerId": @ "id ",
          51. @ "PicUrl": @ "picUrl ",
          52. @ "ToDetailUrl": @ "toDetailUrl ",
          53. @ "Width": @ "width ",
          54. @ "Height": @ "height"
          55. };
          56. }
          58. # Pragma mark-Managed object serialization
          60. + (NSString *) managedObjectEntityName {
          61. Return @ "Banner ";
          62. }
          64. + (NSDictionary *) managedObjectKeysByPropertyKey {
          65. Return nil;
          66. }
          68. @ End
              
              

              2. coredata persistence class

              Brief Introduction to main elements of Coredata

              There are a lot of pictures on the Internet, but I still think this picture on a book is the best:

              
              

              • 1. Managed Object Model
                The Managed Object Model is a data Model that describes an application. This Model contains entities, properties, and Fetch requests. (English terms are used below .)
                
                2, Managed Object Context
                Managed Object Context participates in the whole process of various operations on the data Object, and monitors the changes of the data Object to provide support for undo/redo and update the UI bound to the data.
                
                3. Persistent Store Coordinator
                Persistent Store Coordinator is equivalent to the data file manager, which processes the underlying reading and writing of data files. Generally, we do not need to deal with it.
                
                4. Managed Object
                The Managed Object data Object, which is associated with the Managed Object Context.
              • 
                5, Controller
                In the figure, the green controllers include Array Controller, Object Controller, and Tree Controller. These controllers are usually bound to Managed Object Context through control + drag, so that we can operate data visually in nib.
                

                . H file

                [Objc]View plaincopyprint?
                1. # Import
                3. @ Interface Persistence: NSObject
                5. // Data model object
                6. @ Property (strong, nonatomic) NSManagedObjectModel * managedObjectModel;
                7. // Context object
                8. @ Property (strong, nonatomic) NSManagedObjectContext * managedObjectContext;
                9. // Persistent storage Zone
                10. @ Property (strong, nonatomic) NSPersistentStoreCoordinator * persistentStoreCoordinator;
                12. // Determine the sqlite file storage path
                13. -(NSURL *) storeURL;
                15. // Initialize the database used by Core Data
                16. -(NSPersistentStoreCoordinator *) persistentStoreCoordinator;
                18. // Initialize the value assignment function of managedObjectModel
                19. -(NSManagedObjectModel *) managedObjectModel;
                21. // The initialization value assignment function of managedObjectContext
                22. -(NSManagedObjectContext *) managedObjectContext;
                24. // Save the MTLModel object to coredata
                25. -(BOOL) saveMTLModel :( MTLModel *) MtlModel
                26. Error :( NSError * _ autoreleasing *) error;
                28. // Extract MTLModel from coredata
                29. -(MTLModel *) getMTLmodel :( MTLModel *) MtlModel
                30. Error :( NSError * _ autoreleasing *) error;
                32. // + (NSFetchRequest *) fetchRequest;
                33. @ End
                    
                    

                    
                    

                    
                    

                    . M file

                    [Objc]View plaincopyprint?
                    1. # Import "Persistence. h"
                    3. @ Implementation Persistence
                    5. @ Synthesize managedObjectContext;
                    6. @ Synthesize managedObjectModel;
                    7. @ Synthesize persistentStoreCoordinator;
                    10. // Determine the sqlite file storage path
                    11. -(NSURL *) storeURL {
                    12. // Obtain the database path
                    13. // NSString * docs = [NSSearchPathForDirectoriesInDomains (NSDocumentDirectory, NSUserDomainMask, YES) lastObject];
                    14. /// CoreData is built on SQLite. The database name must be the same as the Xcdatamodel file.
                    15. // NSURL * storeUrl = [NSURL fileURLWithPath: [docs stringByAppendingPathComponent: @ "CoreData. sqlite"];
                    17. NSArray * export netdir = NSSearchPathForDirectoriesInDomains (NSDocumentationDirectory, NSUserDomainMask, YES );
                    18. NSString * docDir = [opencnetdir objectAtIndex: 0];
                    19. NSString * path = [docDir stringByAppendingPathComponent: @ "CoreData. sqlite"];
                    20. NSURL * storeURL = [NSURL fileURLWithPath: path];
                    21. Return storeURL;
                    22. }
                    25. // Initialize the database used by Core Data
                    26. -(NSManagedObjectModel *) managedObjectModel
                    27. {
                    28. If (managedObjectModel! = Nil ){
                    29. Return managedObjectModel;
                    30. }
                    31. Return [NSManagedObjectModel mergedModelFromBundles: nil];
                    32. }
                    34. // Initialize the value assignment function of managedObjectModel
                    35. -(NSPersistentStoreCoordinator *) persistentStoreCoordinator
                    36. {
                    37. If (persistentStoreCoordinator! = Nil ){
                    38. Return persistentStoreCoordinator;
                    39. }
                    41. NSError * error = nil;
                    42. PersistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc]
                    43. InitWithManagedObjectModel: self. managedObjectModel];
                    44. If (! [PersistentStoreCoordinator addPersistentStoreWithType: NSSQLiteStoreType
                    45. Configuration: nil
                    46. URL: [self storeURL]
                    47. Options: nil
                    48. Error: & error]) {
                    49. NSLog (@ "Error: % @, % @", error, [error userInfo]);
                    50. [NSException raise: @ "open failed" format: @ "Reason: % @", [error localizedDescription];
                    51. }
                    53. Return persistentStoreCoordinator;
                    54. }
                    56. // The initialization value assignment function of managedObjectContext
                    57. -(NSManagedObjectContext *) managedObjectContext
                    58. {
                    59. If (managedObjectContext! = Nil ){
                    60. Return managedObjectContext;
                    61. }
                    63. NSPersistentStoreCoordinator * coordinator = self. persistentStoreCoordinator;
                    65. If (coordinator! = Nil ){
                    66. ManagedObjectContext = [[NSManagedObjectContext alloc] init];
                    67. [ManagedObjectContext setPersistentStoreCoordinator: coordinator];
                    68. }
                    70. Return managedObjectContext;
                    71. }
                    73. // Save the MTLModel object to coredata
                    74. -(BOOL) saveMTLModel :( MTLModel *) MtlModel
                    75. Error :( NSError * _ autoreleasing *) error {
                    76. // ----- Need Add Remove the Entity First START ---------
                    77. NSManagedObject * exsitManagedObject = [self getManagedObject: mtlModel
                    78. Error: error];
                    79. If (exsitManagedObject! = Nil ){
                    80. [Self. managedObjectContext deleteObject: exsitManagedObject];
                    81. [Self. managedObjectContext save: error];
                    82. };
                    83. // ----- Need Add Remove the Entity First END -----------
                    85. NSManagedObject * managedObject = [MTLManagedObjectAdapter
                    86. ManagedObjectFromModel: mtlModel
                    87. Insertingtransfercontext: self. managedObjectContext
                    88. Error: error];
                    90. If (managedObject = nil ){
                    91. NSLog (@ "[NSManagedObject] Error: % @", * error );
                    92. Return NO;
                    93. }
                    95. If (! [Self. managedObjectContext save: error]) {
                    96. NSLog (@ "[self. managedObjectContext] Error: % @", * error );
                    97. Return NO;
                    98. };
                    99. Return YES;
                    100. };
                    102. // Extract MTLModel from coredata
                    103. -(MTLModel *) getMTLmodel :( MTLModel *) MtlModel
                    104. Error :( NSError * _ autoreleasing *) error {
                    106. NSManagedObject * managedObject = [self getManagedObject: mtlModel error: error];
                    107. MTLModel * mrlMotel = [[MTLModel alloc] init];
                    109. MrlMotel = [MTLManagedObjectAdapter modelOfClass: [mtlModel class]
                    110. FromManagedObject: managedObject error: error];
                    112. If (error ){
                    113. NSLog (@ "[mrlMotel] Error: % @", * error );
                    114. }
                    115. Return mrlMotel;
                    116. };
                    118. // Obtain the existing ManagedObject from coredata
                    119. -(NSManagedObject *) getManagedObject :( MTLModel *) MtlModel
                    120. Error :( NSError * _ autoreleasing *) error {
                    121. NSString * entityName = [[mtlModel class] managedObjectEntityName];
                    123. // Obtain the number of objects in entity
                    124. NSFetchRequest * requestCount = [NSFetchRequest fetchRequestWithEntityName: entityName];
                    125. NSUInteger count = [self. managedObjectContext countForFetchRequest: requestCount
                    126. Error: error];
                    127. NSLog (@ "count result: % d", count );
                    128. NSLog (@ "sortDescriptor result: % @", [[mtlModel class] sortDescriptor]);
                    130. // Obtain the first object in entity. This object must exist and be unique.
                    131. If (count = 1 ){
                    132. NSFetchRequest * request = [[NSFetchRequest alloc] init];
                    133. [Request setEntity: [NSEntityDescription entityForName: entityName
                    134. InManagedObjectContext: self. managedObjectContext];
                    135. NSSortDescriptor * sort = [[mtlModel class] sortDescriptor];
                    136. NSArray * sortDes = [[NSArray alloc] initWithObjects: sort, nil];
                    137. [Request setSortDescriptors: sortDes];
                    138. NSArray * getObject = [self. managedObjectContext
                    139. ExecuteFetchRequest: request
                    140. Error: error];
                    142. Return [getObject objectAtIndex: 0];
                    143. }
                    144. Return nil;
                    145. }
                    147. // Delete the sqlite file from the file system
                    148. -(Bool) deleteAllEntities {
                    149. Bool status = NO;
                    150. NSError * error;
                    151. @ Try {
                    152. [[NSFileManager defaultManager] removeItemAtPath: [self storeURL]. path
                    153. Error: & error];
                    154. Status = YES;
                    155. }
                    156. @ Catch (NSException * exception ){
                    157. Status = NO;
                    158. }
                    159. @ Finally {
                    160. Return status;
                    161. }
                    162. }
                    164. @ End
                         
                         
                         3. Background execution Program
                         [Objc]View plaincopyprint?
                         1. -(Void) loadBannerList :( void (^) (NSArray * bannerList, NSError * error) block {
                         3. NSParameterAssert (block );
                         5. [Self POST: @ "webresources/homePage"
                         6. Parameters: nil
                         7. ResultClass: BannerWrapper. class
                         8. ResultKeyPath: nil
                         9. Completion: ^ (AFHTTPRequestOperation * operation, id responseObject, NSError * error ){
                         11. // ----------------------- Persistence DEMO ---------------------
                         12. // If network error, get data from CoreData, else save data into CoreData
                         13. If (! Error ){
                         14. NSError * err;
                         15. Persistence * persistence = [[Persistence alloc] init];
                         16. BOOL save = [persistence saveMTLModel: responseObject error: & err];
                         17. If (save = NO ){
                         18. NSLog (@ "Save ERROR! ");
                         19. }
                         20. } Else {
                         21. NSError * err;
                         22. Persistence * persistence = [[Persistence alloc] init];
                         23. BannerWrapper * resObject = [[BannerWrapper alloc] init];
                         24. BannerWrapper * object = [[BannerWrapper alloc] init];
                         25. Object = [persistence getMTLmodel: resObject error: & err];
                         27. ResponseObject = object;
                         29. // This exception is strange. The Array type returned from coredata is changed to the set type, so a conversion is made temporarily.
                         30. If ([object. bannerList isKindOfClass: [NSSet class]) {
                         31. NSArray * objectArray = [(NSSet *) object. bannerList allObjects];
                         32. (BannerWrapper *) responseObject). bannerList = objectArray;
                         33. }
                         34. }
                         35. //-----------------------------------------------------------
                         37. BannerWrapper * wrapper = responseObject;
                         38. Block (wrapper. bannerList, error );
                         40. }];
                         41. }