1: Warehouse Address: https://github.com/jsonmodel/jsonmodel
The main function is to convert JSON strings into Model entities, or entities into JSON strings; it also contains some content of dictionary conversion; JOSN strings are converted into dictionaries through AFNetworking, and then can be converted to entities through dictionaries;
2: Principle realization:
This paper mainly introduces the principle of entity object transformation, and the others are not introduced in it. It mainly uses the mechanism of application to acquire and exchange attributes.
-(id)initWithDictionary:(NSDictionary*)dict error:(NSError**)err { //check for nil input //1.Empty judgement if (!dict) { if (err) *err = [JSONModelError errorInputIsNil]; return nil; } //invalid input, just create empty instance //2.Type judgement if (![dict isKindOfClass:[NSDictionary class]]) { if (err) *err = [JSONModelError errorInvalidDataWithMessage:@"Attempt to initialize JSONModel object using initWithDictionary:error: but the dictionary parameter was not an 'NSDictionary'."]; return nil; } //create a class instance //3.Core, Initialization Mapping property self = [self init]; if (!self) { //super init didn't succeed if (err) *err = [JSONModelError errorModelIsInvalid]; return nil; } //check incoming data structure //4.Check whether the mapping structure can be derived from dictionary Find the corresponding data if (![self __doesDictionary:dict matchModelWithKeyMapper:self.__keyMapper error:err]) { return nil; } //import the data from a dictionary //5.Data assignment if (![self __importDictionary:dict withKeyMapper:self.__keyMapper validation:YES error:err]) { return nil; } //run any custom model validation //6.Local Data Check if (![self validate:err]) { return nil; } //model is valid! yay! return self; }
2.1: How to get attribute-related modifiers? Runtime mechanism is adopted to obtain attributes in entities and corresponding modifiers through attributes; different characters and symbols represent different modifiers;
Code:
unsigned int propertyCount; objc_property_t *properties = class_copyPropertyList(class, &propertyCount); //loop over the class properties for (unsigned int i = 0; i < propertyCount; i++) { JSONModelClassProperty* p = [[JSONModelClassProperty alloc] init]; //get property name objc_property_t property = properties[i]; const char *propertyName = property_getName(property); p.name = @(propertyName); //JMLog(@"property: %@", p.name); //get property attributes const char *attrs = property_getAttributes(property); NSString* propertyAttributes = @(attrs); NSArray* attributeItems = [propertyAttributes componentsSeparatedByString:@","]; ……. }
The property_getAttributes function returns a list of objc_property_attribute_t structures, which contain name and value. The commonly used attributes are as follows:
Attribute type name value: T value: change
Encoding type name value: C (copy) & (strong) W (weak) empty (assign) and other values: none
Non/Atomic name value: Atomic N (Nonatomic) value: Nonatomic
Variable name value: V value: change
The description obtained by using property_getAttributes is the overall description of all name s and value s available from property_copyAttributeList, such as T@"NSDictionary",C,N,V_dict1.
2.2 NSScanner is used to scan specified characters in strings, especially to translate/convert them into numbers and other strings. You can specify its string attribute when creating NSScaner, and then the scanner will scan every character of the string from beginning to end as you want.
NSScanner* scanner = nil; scanner = [NSScanner scannerWithString: propertyAttributes]; //JMLog(@"attr: %@", [NSString stringWithCString:attrs encoding:NSUTF8StringEncoding]); [scanner scanUpToString:@"T" intoString: nil]; [scanner scanString:@"T" intoString:nil]; //check if the property is an instance of a class if ([scanner scanString:@"@\"" intoString: &propertyType]) { [scanner scanUpToCharactersFromSet:[NSCharacterSet characterSetWithCharactersInString:@"\"<"] intoString:&propertyType]; //JMLog(@"type: %@", propertyClassName); p.type = NSClassFromString(propertyType); p.isMutable = ([propertyType rangeOfString:@"Mutable"].location != NSNotFound); p.isStandardJSONType = [allowedJSONTypes containsObject:p.type]; //read through the property protocols while ([scanner scanString:@"<" intoString:NULL]) { NSString* protocolName = nil; [scanner scanUpToString:@">" intoString: &protocolName]; if ([protocolName isEqualToString:@"Optional"]) { p.isOptional = YES; } else if([protocolName isEqualToString:@"Index"]) { p.isIndex = YES; objc_setAssociatedObject( self.class, &kIndexPropertyNameKey, p.name, OBJC_ASSOCIATION_RETAIN // This is atomic ); } else if([protocolName isEqualToString:@"ConvertOnDemand"]) { p.convertsOnDemand = YES; } else if([protocolName isEqualToString:@"Ignore"]) { p = nil; } else { p.protocol = protocolName; } [scanner scanString:@">" intoString:NULL]; } } //check if the property is a structure else if ([scanner scanString:@"{" intoString: &propertyType]) { [scanner scanCharactersFromSet:[NSCharacterSet alphanumericCharacterSet] intoString:&propertyType]; p.isStandardJSONType = NO; p.structName = propertyType; } //the property must be a primitive else { //the property contains a primitive data type [scanner scanUpToCharactersFromSet:[NSCharacterSet characterSetWithCharactersInString:@","] intoString:&propertyType]; //get the full name of the primitive type propertyType = valueTransformer.primitivesNames[propertyType]; if (![allowedPrimitiveTypes containsObject:propertyType]) { //type not allowed - programmer mistaked -> exception @throw [NSException exceptionWithName:@"JSONModelProperty type not allowed" reason:[NSString stringWithFormat:@"Property type of %@.%@ is not supported by JSONModel.", self.class, p.name] userInfo:nil]; } }
Then, the string of symbols is parsed and analyzed, and the corresponding strings are obtained for judgment processing; the corresponding attributes are added for operation, such as ignorance, nullability, etc., and the attributes modified by block are also directly nullable without conversion; the code is as follows:
NSString *nsPropertyName = @(propertyName); if([[self class] propertyIsOptional:nsPropertyName]){ p.isOptional = YES; } if([[self class] propertyIsIgnored:nsPropertyName]){ p = nil; } //few cases where JSONModel will ignore properties automatically if ([propertyType isEqualToString:@"Block"]) { p = nil; }
2.3 JSONModel modifies the corresponding attribute names for keyMapper
In the following paragraph, we usually replace the Model with a JSON string and rename it with a new attribute name.
+(JSONKeyMapper*)keyMapper { return [[JSONKeyMapper alloc] initWithDictionary:@{ @"new_password": @"my_new_password", }]; }
In fact, in the process of JSONModel initialization, there is a judgment process for keyMapper; judging whether there is this method in the current entity object, if there is and has not been cached by the mapping, then it is processed;
id mapper = [[self class] keyMapper]; if ( mapper && !objc_getAssociatedObject(self.class, &kMapperObjectKey) ) { objc_setAssociatedObject( self.class, &kMapperObjectKey, mapper, OBJC_ASSOCIATION_RETAIN // This is atomic ); }
The description of the use of & kClassPropertiesKey, & kMapper ObjectKey, is the identity of the mapping cache.
//Use AssociateObject Mapping property Cache to determine whether it has been mapped if (!objc_getAssociatedObject(self.class, &kClassPropertiesKey)) { [self __inspectProperties]; } //Same use AssociateObject Mapping property Caching if ( mapper && !objc_getAssociatedObject(self.class, &kMapperObjectKey) ) { }
Write the identity as follows:
objc_setAssociatedObject( self.class, &kClassPropertiesKey, [propertyIndex copy], OBJC_ASSOCIATION_RETAIN // This is atomic );
2.4 Lack of Judgment on Health Value
Get the attribute values of the current entity, and make no judgment on those empty, so they are not placed in the NSMutableSet below.
-(NSMutableSet*)__requiredPropertyNames { //fetch the associated property names NSMutableSet* classRequiredPropertyNames = objc_getAssociatedObject(self.class, &kClassRequiredPropertyNamesKey); if (!classRequiredPropertyNames) { classRequiredPropertyNames = [NSMutableSet set]; [[self __properties__] enumerateObjectsUsingBlock:^(JSONModelClassProperty* p, NSUInteger idx, BOOL *stop) { if (!p.isOptional) [classRequiredPropertyNames addObject:p.name]; }]; //persist the list objc_setAssociatedObject( self.class, &kClassRequiredPropertyNamesKey, classRequiredPropertyNames, OBJC_ASSOCIATION_RETAIN // This is atomic ); } return classRequiredPropertyNames; }
This side should be compatible with other attributes in dic dictionary and handle the replacement attributes if there is KeyMapper, and then make a unified judgment.
-(BOOL)__doesDictionary:(NSDictionary*)dict matchModelWithKeyMapper:(JSONKeyMapper*)keyMapper error:(NSError**)err { //check if all required properties are present NSArray* incomingKeysArray = [dict allKeys]; NSMutableSet* requiredProperties = [self __requiredPropertyNames]; NSSet* incomingKeys = [NSSet setWithArray: incomingKeysArray]; //transform the key names, if neccessary if (keyMapper || globalKeyMapper) { NSMutableSet* transformedIncomingKeys = [NSMutableSet setWithCapacity: requiredProperties.count]; NSString* transformedName = nil; //loop over the required properties list for (JSONModelClassProperty* property in [self __properties__]) { transformedName = (keyMapper||globalKeyMapper) ? [self __mapString:property.name withKeyMapper:keyMapper importing:YES] : property.name; //chek if exists and if so, add to incoming keys id value; @try { value = [dict valueForKeyPath:transformedName]; } @catch (NSException *exception) { value = dict[transformedName]; } if (value) { [transformedIncomingKeys addObject: property.name]; } } //overwrite the raw incoming list with the mapped key names incomingKeys = transformedIncomingKeys; } //check for missing input keys if (![requiredProperties isSubsetOfSet:incomingKeys]) { //get a list of the missing properties [requiredProperties minusSet:incomingKeys]; //not all required properties are in - invalid input JMLog(@"Incoming data was invalid [%@ initWithDictionary:]. Keys missing: %@", self.class, requiredProperties); if (err) *err = [JSONModelError errorInvalidDataWithMissingKeys:requiredProperties]; return NO; } //not needed anymore incomingKeys= nil; requiredProperties= nil; return YES; }
2.5 Start assigning
First, we get the corresponding array of attribute lists.
-(NSArray*)__properties__ { //fetch the associated object NSDictionary* classProperties = objc_getAssociatedObject(self.class, &kClassPropertiesKey); if (classProperties) return [classProperties allValues]; //if here, the class needs to inspect itself [self __setup__]; //return the property list classProperties = objc_getAssociatedObject(self.class, &kClassPropertiesKey); return [classProperties allValues]; }
Then we mainly assign attributes.
-(BOOL)__importDictionary:(NSDictionary*)dict withKeyMapper:(JSONKeyMapper*)keyMapper validation:(BOOL)validation error:(NSError**)err { //loop over the incoming keys and set self's properties //Mapped by cyclic traversal JSONModelClassProperty structural morphology for (JSONModelClassProperty* property in [self __properties__]) { //convert key name ot model keys, if a mapper is provided //keyMapper Mapping to get the real value of the town NSString* jsonKeyPath = (keyMapper||globalKeyMapper) ? [self __mapString:property.name withKeyMapper:keyMapper importing:YES] : property.name; //JMLog(@"keyPath: %@", jsonKeyPath); //general check for data type compliance id jsonValue; @try { jsonValue = [dict valueForKeyPath: jsonKeyPath]; } @catch (NSException *exception) { jsonValue = dict[jsonKeyPath]; } //check for Optional properties if (isNull(jsonValue)) { //skip this property, continue with next property if (property.isOptional || !validation) continue; if (err) { //null value for required property NSString* msg = [NSString stringWithFormat:@"Value of required model key %@ is null", property.name]; JSONModelError* dataErr = [JSONModelError errorInvalidDataWithMessage:msg]; *err = [dataErr errorByPrependingKeyPathComponent:property.name]; } return NO; } Class jsonValueClass = [jsonValue class]; BOOL isValueOfAllowedType = NO; //Is it permissible to determine the type of data input? json type for (Class allowedType in allowedJSONTypes) { if ( [jsonValueClass isSubclassOfClass: allowedType] ) { isValueOfAllowedType = YES; break; } } if (isValueOfAllowedType==NO) { //type not allowed JMLog(@"Type %@ is not allowed in JSON.", NSStringFromClass(jsonValueClass)); if (err) { NSString* msg = [NSString stringWithFormat:@"Type %@ is not allowed in JSON.", NSStringFromClass(jsonValueClass)]; JSONModelError* dataErr = [JSONModelError errorInvalidDataWithMessage:msg]; *err = [dataErr errorByPrependingKeyPathComponent:property.name]; } return NO; } //check if there's matching property in the model if (property) { // check for custom setter, than the model doesn't need to do any guessing // how to read the property's value from JSON // Corresponding to the object used setter Method to carry out set if ([self __customSetValue:jsonValue forProperty:property]) { //skip to next JSON key continue; }; // 0) handle primitives // Represents the underlying type, such as int float Wait, use it directly kvc assignment if (property.type == nil && property.structName==nil) { //generic setter if (jsonValue != [self valueForKey:property.name]) { [self setValue:jsonValue forKey: property.name]; } //skip directly to the next key continue; } // 0.5) handle nils if (isNull(jsonValue)) { if ([self valueForKey:property.name] != nil) { [self setValue:nil forKey: property.name]; } continue; } // 1) check if property is itself a JSONModel // Determine whether the substructure is one? JSONModel Structures, recursive traversal, first the sub-structure traversal and assignment complete if ([self __isJSONModelSubClass:property.type]) { //initialize the property's model, store it JSONModelError* initErr = nil; id value = [[property.type alloc] initWithDictionary: jsonValue error:&initErr]; if (!value) { //skip this property, continue with next property if (property.isOptional || !validation) continue; // Propagate the error, including the property name as the key-path component if((err != nil) && (initErr != nil)) { *err = [initErr errorByPrependingKeyPathComponent:property.name]; } return NO; } if (![value isEqual:[self valueForKey:property.name]]) { [self setValue:value forKey: property.name]; } //for clarity, does the same without continue continue; } else { // 2) check if there's a protocol to the property // ) might or not be the case there's a built in transform for it // Does it contain protocol A field that is used primarily to indicate array perhaps dictionary Object type in if (property.protocol) { //JMLog(@"proto: %@", p.protocol); //Loop through the sub-content, assigning the corresponding type to the corresponding array perhaps dictionary jsonValue = [self __transform:jsonValue forProperty:property error:err]; if (!jsonValue) { if ((err != nil) && (*err == nil)) { NSString* msg = [NSString stringWithFormat:@"Failed to transform value, but no error was set during transformation. (%@)", property]; JSONModelError* dataErr = [JSONModelError errorInvalidDataWithMessage:msg]; *err = [dataErr errorByPrependingKeyPathComponent:property.name]; } return NO; } } // 3.1) handle matching standard JSON types // Criteria json Types, such as nsstring etc. if (property.isStandardJSONType && [jsonValue isKindOfClass: property.type]) { //mutable properties if (property.isMutable) { jsonValue = [jsonValue mutableCopy]; } //set the property value if (![jsonValue isEqual:[self valueForKey:property.name]]) { [self setValue:jsonValue forKey: property.name]; } continue; } // 3.3) handle values to transform // Other processing scenarios, mainly some type conversion scenarios, such as nsstring Convert to nsurl etc. if ( (![jsonValue isKindOfClass:property.type] && !isNull(jsonValue)) || //the property is mutable property.isMutable || //custom struct property property.structName ) { // searched around the web how to do this better // but did not find any solution, maybe that's the best idea? (hardly) // Acquire authenticity json data type Class sourceClass = [JSONValueTransformer classByResolvingClusterClasses:[jsonValue class]]; //JMLog(@"to type: [%@] from type: [%@] transformer: [%@]", p.type, sourceClass, selectorName); //build a method selector for the property and json object classes // adopt property Type and json Judgment of Data Type Conversion NSString* selectorName = [NSString stringWithFormat:@"%@From%@:", (property.structName? property.structName : property.type), //target name sourceClass]; //source name SEL selector = NSSelectorFromString(selectorName); //check for custom transformer //Is there a local conversion method? BOOL foundCustomTransformer = NO; if ([valueTransformer respondsToSelector:selector]) { foundCustomTransformer = YES; } else { //try for hidden custom transformer selectorName = [NSString stringWithFormat:@"__%@",selectorName]; selector = NSSelectorFromString(selectorName); if ([valueTransformer respondsToSelector:selector]) { foundCustomTransformer = YES; } } //check if there's a transformer with that name if (foundCustomTransformer) { //it's OK, believe me... #pragma clang diagnostic push #pragma clang diagnostic ignored "-Warc-performSelector-leaks" //transform the value // adopt JSONValueTransformer Type conversion jsonValue = [valueTransformer performSelector:selector withObject:jsonValue]; #pragma clang diagnostic pop if (![jsonValue isEqual:[self valueForKey:property.name]]) { [self setValue:jsonValue forKey: property.name]; } } else { // it's not a JSON data type, and there's no transformer for it // if property type is not supported - that's a programmer mistake -> exception @throw [NSException exceptionWithName:@"Type not allowed" reason:[NSString stringWithFormat:@"%@ type not supported for %@.%@", property.type, [self class], property.name] userInfo:nil]; return NO; } } else { // 3.4) handle "all other" cases (if any) if (![jsonValue isEqual:[self valueForKey:property.name]]) { [self setValue:jsonValue forKey: property.name]; } } } } } return YES; }
Whether the type corresponding to the value is in the supported transformation type
allowedJSONTypes = @[ [NSString class], [NSNumber class], [NSDecimalNumber class], [NSArray class], [NSDictionary class], [NSNull class], //immutable JSON classes [NSMutableString class], [NSMutableArray class], [NSMutableDictionary class] //mutable JSON classes ]; allowedPrimitiveTypes = @[ @"BOOL", @"float", @"int", @"long", @"double", @"short", //and some famous aliases @"NSInteger", @"NSUInteger", @"Block" ];
Then the above code is used for the following judgment
Class jsonValueClass = [jsonValue class]; BOOL isValueOfAllowedType = NO; for (Class allowedType in allowedJSONTypes) { if ( [jsonValueClass isSubclassOfClass: allowedType] ) { isValueOfAllowedType = YES; break; } }
2.6 Define empty protocols to distinguish some attribute identifiers
@protocol Ignore @end /** * Protocol for defining optional properties in a JSON Model class. Use like below to define * model properties that are not required to have values in the JSON input: * * @property (strong, nonatomic) NSString<Optional>* propertyName; * */ @protocol Optional @end /** * Protocol for defining index properties in a JSON Model class. Use like below to define * model properties that are considered the Model's identifier (id). * * @property (strong, nonatomic) NSString<Index>* propertyName; * */ @protocol Index @end //Make all objects optionally compatible and avoid compiler warnings @interface NSObject(JSONModelPropertyCompatibility)<Optional, Index, Ignore> @end
In particular, Optional is a nullable identifier, such as when we set a property to be nullable @property (nonatomic, copy) NSString < Optional > * current_status;, and then configure some properties in the string above to get the property about whether or not the identifier string exists; it is included in <>;
while ([scanner scanString:@"<" intoString:NULL]) { NSString* protocolName = nil; [scanner scanUpToString:@">" intoString: &protocolName]; if ([protocolName isEqualToString:@"Optional"]) { p.isOptional = YES; } else if([protocolName isEqualToString:@"Index"]) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" p.isIndex = YES; #pragma GCC diagnostic pop objc_setAssociatedObject( self.class, &kIndexPropertyNameKey, p.name, OBJC_ASSOCIATION_RETAIN // This is atomic ); } else if([protocolName isEqualToString:@"Ignore"]) { p = nil; } else { p.protocol = protocolName; } [scanner scanString:@">" intoString:NULL]; } }
3: Examples of obtaining attribute types
Define a class:
@interface MPAllModel : JSONModel @property(nonatomic,copy)NSString *name; @property(nonatomic,strong)NSString *userName; @property(nonatomic)int age; @property(nonatomic)float price; @property(nonatomic,strong)NSNumber *isShow; @property(nonatomic,assign)BOOL isError; @property(nonatomic,strong)NSArray *itemArray; @property(nonatomic,strong)NSArray<Optional> *dataArray; @end
Then, using the runtime code, we get the string contents of the corresponding attributes of this class:
unsigned int outCount; int i; objc_property_t *property = class_copyPropertyList([MPAllModel class], &outCount); for (i = outCount -1; i >= 0 ; i--) { NSString *getPropertyName = [NSString stringWithCString:property_getName(property[i]) encoding:NSUTF8StringEncoding]; NSLog(@"getPropertyName: %@",getPropertyName); NSString *getPropertyNameString = [NSString stringWithCString:property_getAttributes(property[i]) encoding:NSUTF8StringEncoding]; NSLog(@"getPropertyNameString: %@",getPropertyNameString); }
The following corresponding types are obtained:
getPropertyName: dataArray getPropertyNameString: T@"NSArray<Optional>",&,N,V_dataArray getPropertyName: itemArray getPropertyNameString: T@"NSArray",&,N,V_itemArray getPropertyName: isError getPropertyNameString: TB,N,V_isError getPropertyName: isShow getPropertyNameString: T@"NSNumber",&,N,V_isShow getPropertyName: price getPropertyNameString: Tf,N,V_price getPropertyName: age getPropertyNameString: Ti,N,V_age getPropertyName: userName getPropertyNameString: T@"NSString",&,N,V_userName getPropertyName: name getPropertyNameString: T@"NSString",C,N,V_name