下拉刷新控件：MJRefreshNormalHeader
上拉加载控件：MJRefreshAutoNormalFooter、MJRefreshBackNormalFooter
左滑加载控件：MJRefreshNormalTrailer

// 1.初始化
- (instancetype)initWithFrame:(CGRect)frame{;}

// 2.准备工作
- (void)prepare{;}

// 3.视图即将被父视图加入
- (void)willMoveToSuperview:(UIView *)newSuperview{
    // 滚动视图初始值的记录
    // 一些值的更新
    // 监听事件的更新
}

// 4.布局
- (void)layoutSubviews{
    [self placeSubviews];
}

// 当偏移值发生变化
- (void)scrollViewContentOffsetDidChange:(NSDictionary *)change{}
// 当内容大小发生变化
- (void)scrollViewContentSizeDidChange:(NSDictionary *)change{}
// 当点击手势状态发生变化
- (void)scrollViewPanStateDidChange:(NSDictionary *)change{}

// 状态设置
- (void)setState:(MJRefreshState)state{;}

// 进入刷新状态
- (void)beginRefreshing{;}
// 结束刷新状态
- (void)endRefreshing{;}

// 自动切换透明度
- (void)setAutoChangeAlpha:(BOOL)autoChangeAlpha{;}
- (BOOL)isAutoChangeAlpha{;}
- (void)setAutomaticallyChangeAlpha:(BOOL)automaticallyChangeAlpha{;}

// 根据拖拽进度实时设置透明度
- (void)setPullingPercent:(CGFloat)pullingPercent{;}

- (void)prepare {
    [super prepare];
    // 设置存储key
    // 设置Header的高度
}

- (void)placeSubviews {
    [super placeSubviews];    
    // 设置Header的位置（y坐标）
}

if (self.scrollView.isDragging) { // 如果正在拖拽
    self.pullingPercent = pullingPercent;

    // 当拖拽时的偏移量大于临界值，且原状态为闲置时，将状态置为即将刷新
    if (self.state == MJRefreshStateIdle && offsetY < normal2pullingOffsetY) {
        // 转为即将刷新状态
        self.state = MJRefreshStatePulling;
    }
    // 当拖拽时的偏移量小于临界值，且原状态为即将刷新时，将状态重置会闲置
    else if (self.state == MJRefreshStatePulling && offsetY >= normal2pullingOffsetY) {
        // 转为普通状态
        self.state = MJRefreshStateIdle;
    }
}
// 原状态为即将刷新，且手已松开
else if (self.state == MJRefreshStatePulling) {
    // 开始刷新
    [self beginRefreshing];
}
// 未达到刷新的偏移量，且手已松开
else if (pullingPercent < 1) {
    // 记录header露出的百分比
    self.pullingPercent = pullingPercent;
}

- (void)setState:(MJRefreshState)state{
    _state = state;

    // 加入主队列的目的是等setState:方法调用完毕、设置完文字后再去布局子控件
    MJRefreshDispatchAsyncOnMainQueue([self setNeedsLayout];)
}

1.开始刷新方法调用
- (void)beginRefreshing{
   // ...
   self.state = MJRefreshStateRefreshing;
   // ...
}

2.设置状态为正在刷新中
- (void)setState:(MJRefreshState)state{
    MJRefreshCheckState

    // 根据状态做事情
    if (state == MJRefreshStateIdle) {
        //...        
    } else if (state == MJRefreshStateRefreshing) {
        [self headerRefreshingAction];
    }
}
3.执行刷新动作
- (void)headerRefreshingAction {
    // 主要代码
    [UIView animateWithDuration:MJRefreshFastAnimationDuration animations:^{
        if (self.scrollView.panGestureRecognizer.state != UIGestureRecognizerStateCancelled) {
            CGFloat top = self.scrollViewOriginalInset.top + self.mj_h;
            // 增加滚动区域top
            self.scrollView.mj_insetT = top;
            // 设置滚动位置
            CGPoint offset = self.scrollView.contentOffset;
            offset.y = -top;
            [self.scrollView setContentOffset:offset animated:NO];
        }
    } completion:^(BOOL finished) {
        [self executeRefreshingCallback];
    }];
}

1.结束刷新方法调用
- (void)endRefreshing{
    MJRefreshDispatchAsyncOnMainQueue(self.state = MJRefreshStateIdle;)
}
2.设置状态为闲置
- (void)setState:(MJRefreshState)state{
    MJRefreshCheckState

    // 根据状态做事情
    if (state == MJRefreshStateIdle) {
        if (oldState != MJRefreshStateRefreshing) return;

        [self headerEndingAction];
    } else if (state == MJRefreshStateRefreshing) {
        // ...
    }
}
3.执行结束动作
- (void)headerEndingAction {;}

- (void)scrollViewContentSizeDidChange:(NSDictionary *)change
{
    [super scrollViewContentSizeDidChange:change];

    // 内容的高度
    CGFloat contentHeight = self.scrollView.mj_contentH + self.ignoredScrollViewContentInsetBottom;
    // 表格的高度
    CGFloat scrollHeight = self.scrollView.mj_h - self.scrollViewOriginalInset.top - self.scrollViewOriginalInset.bottom + self.ignoredScrollViewContentInsetBottom;
    // 设置位置和尺寸
    self.mj_y = MAX(contentHeight, scrollHeight);
}

#pragma mark 获得scrollView的内容 超出 view 的高度
- (CGFloat)heightForContentBreakView
{
    CGFloat h = self.scrollView.frame.size.height - self.scrollViewOriginalInset.bottom - self.scrollViewOriginalInset.top;
    return self.scrollView.contentSize.height - h;
}

#pragma mark 刚好看到上拉刷新控件时的contentOffset.y
- (CGFloat)happenOffsetY
{
    CGFloat deltaH = [self heightForContentBreakView];
    // 内容和视图的高度差
    if (deltaH > 0) {
        //  内容高度 > 视图高度
        return deltaH - self.scrollViewOriginalInset.top;
    } else {
        // 内容高度 < 视图高度
        return - self.scrollViewOriginalInset.top;
    }
}

- (void)willMoveToSuperview:(UIView *)newSuperview
{
    [super willMoveToSuperview:newSuperview];

    if (newSuperview) { // 新的父控件
        if (self.hidden == NO) {
            self.scrollView.mj_insetB += self.mj_h;
        }

        // 设置位置
        self.mj_y = _scrollView.mj_contentH;
    } else { // 被移除了
        if (self.hidden == NO) {
            self.scrollView.mj_insetB -= self.mj_h;
        }
    }
}

- (void)scrollViewPanStateDidChange:(NSDictionary *)change
{
    [super scrollViewPanStateDidChange:change];

    if (self.state != MJRefreshStateIdle) return;

    UIGestureRecognizerState panState = _scrollView.panGestureRecognizer.state;

    switch (panState) {
        // 手松开
        case UIGestureRecognizerStateEnded: {
            if (_scrollView.mj_insetT + _scrollView.mj_contentH <= _scrollView.mj_h) {
                // 内容 < 控件高度
                if (_scrollView.mj_offsetY >= - _scrollView.mj_insetT) { // 向上拽
                    self.triggerByDrag = YES;
                    [self beginRefreshing];
                }
            } else {
                // 内容 > 控件高度
                if (_scrollView.mj_offsetY >= _scrollView.mj_contentH + _scrollView.mj_insetB - _scrollView.mj_h) {
                    self.triggerByDrag = YES;
                    [self beginRefreshing];
                }
            }
        }
            break;

        case UIGestureRecognizerStateBegan: {
            [self resetTriggerTimes];
        }
            break;

        default:
            break;
    }
}

- (void)scrollViewContentOffsetDidChange:(NSDictionary *)change
{
    [super scrollViewContentOffsetDidChange:change];

    if (self.state != MJRefreshStateIdle || !self.automaticallyRefresh || self.mj_y == 0) return;

    // 当autoTriggerTimes被设置成-1（滚动时无限加载）
    // 该方法保证拖动放手后，视图还在滚动的情况下，一直保持加载状态

    // 内容超出控件高度
    if (_scrollView.mj_insetT + _scrollView.mj_contentH > _scrollView.mj_h) {

        //  内容高度 - 控件高度 + 控件底部边距 + footer高度 * 百分比 - footer高度
        //  内容高度 - 控件高度 + 控件底部边距
        if (_scrollView.mj_offsetY >= _scrollView.mj_contentH - _scrollView.mj_h + self.mj_h * self.triggerAutomaticallyRefreshPercent + _scrollView.mj_insetB - self.mj_h) {
            // 防止手松开时连续调用
            CGPoint old = [change[@"old"] CGPointValue];
            CGPoint new = [change[@"new"] CGPointValue];
            if (new.y <= old.y) return;

            if (_scrollView.isDragging) {
                self.triggerByDrag = YES;
            }
            // 当底部刷新控件完全出现时，才刷新
            [self beginRefreshing];
        }
    }
}

/** 自动触发次数, 默认为 1, 仅在拖拽 ScrollView 时才生效,

 如果为 -1, 则为无限触发
 */
@property (nonatomic) NSInteger autoTriggerTimes;

- (void)beginRefreshing{
    // 新的拖拽动作 && 剩余触发次数 && 是否无限触发
    if (self.triggerByDrag && self.leftTriggerTimes <= 0 && !self.unlimitedTrigger) {
        return;
    }

    [super beginRefreshing];
}

- (void)setState:(MJRefreshState)state{
    MJRefreshCheckState

    if (state == MJRefreshStateRefreshing) {
        // 执行加载数据回调
        [self executeRefreshingCallback];
    } else if (state == MJRefreshStateNoMoreData || state == MJRefreshStateIdle) {
        if (self.triggerByDrag) {
            if (!self.unlimitedTrigger) {
                self.leftTriggerTimes -= 1;
            }
            self.triggerByDrag = NO;
        }

        /** 结束刷新 */
        if (MJRefreshStateRefreshing == oldState) {

            // 当视图开启了分页显示，设置动画和回调
            if (self.scrollView.pagingEnabled) {
                CGPoint offset = self.scrollView.contentOffset;
                offset.y -= self.scrollView.mj_insetB;
                [UIView animateWithDuration:MJRefreshSlowAnimationDuration animations:^{
                    self.scrollView.contentOffset = offset;

                    if (self.endRefreshingAnimationBeginAction) {
                        self.endRefreshingAnimationBeginAction();
                    }
                } completion:^(BOOL finished) {
                    if (self.endRefreshingCompletionBlock) {
                        self.endRefreshingCompletionBlock();
                    }
                }];

                return;
            }

            // 结束刷新回调
            if (self.endRefreshingCompletionBlock) {
                self.endRefreshingCompletionBlock();
            }
        }
    }
}

- (void)setImages:(NSArray *)images duration:(NSTimeInterval)duration forState:(MJRefreshState)state
{
    if (images == nil) return;

    self.stateImages[@(state)] = images;
    self.stateDurations[@(state)] = @(duration);

    /* 根据图片设置控件的高度 */
    UIImage *image = [images firstObject];
    if (image.size.height > self.mj_h) {
        self.mj_h = image.size.height;
    }
}

- (void)setImages:(NSArray *)images forState:(MJRefreshState)state {
    [self setImages:images duration:images.count * 0.1 forState:state];
}

// 通过拖拽百分比设置 Idle~Pulling状态之间的 对应的动画帧
- (void)setPullingPercent:(CGFloat)pullingPercent
{
    [super setPullingPercent:pullingPercent];
    NSArray *images = self.stateImages[@(MJRefreshStateIdle)];
    if (self.state != MJRefreshStateIdle || images.count == 0) return;
    // 停止动画
    [self.gifView stopAnimating];


    // 设置当前需要显示的图片
    NSUInteger index =  images.count * pullingPercent;
    if (index >= images.count) index = images.count - 1;
    self.gifView.image = images[index];
}

- (void)setState:(MJRefreshState)state
{
    MJRefreshCheckState

    // 根据状态做事情
    if (state == MJRefreshStatePulling || state == MJRefreshStateRefreshing) {
        // 即将刷新 和 刷新中 状态的动画
        NSArray *images = self.stateImages[@(state)];
        if (images.count == 0) return;

        [self.gifView stopAnimating];
        if (images.count == 1) { // 单张图片
            self.gifView.image = [images lastObject];
        } else { // 多张图片
            self.gifView.animationImages = images;
            self.gifView.animationDuration = [self.stateDurations[@(state)] doubleValue];
            [self.gifView startAnimating];
        }
    } else if (state == MJRefreshStateIdle) {
        // 限制状态停止动画
        [self.gifView stopAnimating];
    }
}

pod 'YYModel', '~> 1.0.4'

pod 'MJExtension', '~> 3.2.2'

// JSON|字典 转 模型
+ (instancetype)mj_objectWithKeyValues:(id)keyValues;

// 通过 JSON|字典 为 模型赋值
- (instancetype)mj_setKeyValues:(id)keyValues;

// 模型转JSON
- (NSMutableDictionary *)mj_keyValues;

// JSON数组转模型数组
+ (NSMutableArray *)mj_objectArrayWithKeyValuesArray:(id)keyValuesArray;

+ (instancetype)mj_objectWithKeyValues:(id)keyValues context:(NSManagedObjectContext *)context
{
    // 获得JSON对象
    keyValues = [keyValues mj_JSONObject];
    MJExtensionAssertError([keyValues isKindOfClass:[NSDictionary class]], nil, [self class], @"keyValues参数不是一个字典");

    // 判断是否传入 "contenxt" 参数
    if ([self isSubclassOfClass:[NSManagedObject class]] && context) {
        NSString *entityName = [NSStringFromClass(self) componentsSeparatedByString:@"."].lastObject;
        return [[NSEntityDescription insertNewObjectForEntityForName:entityName inManagedObjectContext:context] mj_setKeyValues:keyValues context:context];
    }
    return [[[self alloc] init] mj_setKeyValues:keyValues];
}

// 获得JSON对象
keyValues = [keyValues mj_JSONObject];
MJExtensionAssertError([keyValues isKindOfClass:[NSDictionary class]], self, [self class], @"keyValues参数不是一个字典");

Class clazz = [self class];
NSArray *allowedPropertyNames = [clazz mj_totalAllowedPropertyNames];
NSArray *ignoredPropertyNames = [clazz mj_totalIgnoredPropertyNames];

//通过封装的方法回调一个通过运行时编写的，用于返回属性列表的方法。
[clazz mj_enumerateProperties:^(MJProperty *property, BOOL *stop) {
    @try {
        // 0.检测是否被忽略
        if (allowedPropertyNames.count && ![allowedPropertyNames containsObject:property.name]) return;
        if ([ignoredPropertyNames containsObject:property.name]) return;

        // 1.取出属性值
        id value;
        NSArray *propertyKeyses = [property propertyKeysForClass:clazz];
        for (NSArray *propertyKeys in propertyKeyses) {
            value = keyValues;
            for (MJPropertyKey *propertyKey in propertyKeys) {
                value = [propertyKey valueInObject:value];
            }
            if (value) break;
        }

        // 值的过滤
        id newValue = [clazz mj_getNewValueFromObject:self oldValue:value property:property];
        if (newValue != value) { // 有过滤后的新值
            [property setValue:newValue forObject:self];
            return;
        }

        // 如果没有值，就直接返回
        if (!value || value == [NSNull null]) return;

        // 2.复杂处理
        MJPropertyType *type = property.type; // 数据类型类
        Class propertyClass = type.typeClass; // 对象类型
        Class objectClass = [property objectClassInArrayForClass:[self class]]; // 数组中的模型类型

        // 不可变 -> 可变处理
        if (propertyClass == [NSMutableArray class] && [value isKindOfClass:[NSArray class]]) {
            value = [NSMutableArray arrayWithArray:value];
        } else if (propertyClass == [NSMutableDictionary class] && [value isKindOfClass:[NSDictionary class]]) {
            value = [NSMutableDictionary dictionaryWithDictionary:value];
        } else if (propertyClass == [NSMutableString class] && [value isKindOfClass:[NSString class]]) {
            value = [NSMutableString stringWithString:value];
        } else if (propertyClass == [NSMutableData class] && [value isKindOfClass:[NSData class]]) {
            value = [NSMutableData dataWithData:value];
        }

        if (!type.isFromFoundation && propertyClass) { // 模型属性
            // 既不是基础类型，也不是NS类型。即：基本数据类型
            value = [propertyClass mj_objectWithKeyValues:value context:context];
        } else if (objectClass) {
            if (objectClass == [NSURL class] && [value isKindOfClass:[NSArray class]]) {
                // string array -> url array
                NSMutableArray *urlArray = [NSMutableArray array];
                for (NSString *string in value) {
                    if (![string isKindOfClass:[NSString class]]) continue;
                    [urlArray addObject:string.mj_url];
                }
                value = urlArray;
            } else { // 字典数组-->模型数组
                value = [objectClass mj_objectArrayWithKeyValuesArray:value context:context];
            }
        } else if (propertyClass == [NSString class]) {
            if ([value isKindOfClass:[NSNumber class]]) {
                // NSNumber -> NSString
                value = [value description];
            } else if ([value isKindOfClass:[NSURL class]]) {
                // NSURL -> NSString
                value = [value absoluteString];
            }
        } else if ([value isKindOfClass:[NSString class]]) {
            if (propertyClass == [NSURL class]) {
                // NSString -> NSURL
                // 字符串转码
                value = [value mj_url];
            } else if (type.isNumberType) {
                NSString *oldValue = value;

                // NSString -> NSDecimalNumber, 使用 DecimalNumber 来转换数字, 避免丢失精度以及溢出
                NSDecimalNumber *decimalValue = [NSDecimalNumber decimalNumberWithString:oldValue
                                                                                  locale:numberLocale];

                // 检查特殊情况
                if (decimalValue == NSDecimalNumber.notANumber) {
                    value = @(0);
                }else if (propertyClass != [NSDecimalNumber class]) {
                    value = [decimalValue mj_standardValueWithTypeCode:type.code];
                } else {
                    value = decimalValue;
                }

                // 如果是BOOL
                if (type.isBoolType) {
                    // 字符串转BOOL（字符串没有charValue方法）
                    // 系统会调用字符串的charValue转为BOOL类型
                    NSString *lower = [oldValue lowercaseString];
                    if ([lower isEqualToString:@"yes"] || [lower isEqualToString:@"true"]) {
                        value = @YES;
                    } else if ([lower isEqualToString:@"no"] || [lower isEqualToString:@"false"]) {
                        value = @NO;
                    }
                }
            }
        } else if ([value isKindOfClass:[NSNumber class]] && propertyClass == [NSDecimalNumber class]){
            // 过滤 NSDecimalNumber类型
            if (![value isKindOfClass:[NSDecimalNumber class]]) {
                value = [NSDecimalNumber decimalNumberWithDecimal:[((NSNumber *)value) decimalValue]];
            }
        }

        // 经过转换后, 最终检查 value 与 property 是否匹配
        if (propertyClass && ![value isKindOfClass:propertyClass]) {
            value = nil;
        }

        // 3.赋值（KVC）
        [property setValue:value forObject:self];
    } @catch (NSException *exception) {
        MJExtensionBuildError([self class], exception.reason);
        MJExtensionLog(@"%@", exception);
    }
}];

// 白名单
if (allowedPropertyNames.count && ![allowedPropertyNames containsObject:property.name]) return;
// 黑名单
if ([ignoredPropertyNames containsObject:property.name]) return;

id value;
NSArray *propertyKeyses = [property propertyKeysForClass:clazz];
for (NSArray *propertyKeys in propertyKeyses) {
    value = keyValues;
    for (MJPropertyKey *propertyKey in propertyKeys) {
        value = [propertyKey valueInObject:value];
    }
    if (value) break;
}

// 值的过滤
id newValue = [clazz mj_getNewValueFromObject:self oldValue:value property:property];
if (newValue != value) { // 有过滤后的新值
    [property setValue:newValue forObject:self];
    return;
}

// 如果没有值，就直接返回
if (!value || value == [NSNull null]) return;

MJPropertyType *type = property.type; // 数据类型的信息
Class propertyClass = type.typeClass; // 属性的类型
Class objectClass = [property objectClassInArrayForClass:[self class]]; // 数组中模型的类型

// 不可变 -> 可变处理
if (propertyClass == [NSMutableArray class] && [value isKindOfClass:[NSArray class]]) {
    value = [NSMutableArray arrayWithArray:value];
} else if (propertyClass == [NSMutableDictionary class] && [value isKindOfClass:[NSDictionary class]]) {
    value = [NSMutableDictionary dictionaryWithDictionary:value];
} else if (propertyClass == [NSMutableString class] && [value isKindOfClass:[NSString class]]) {
    value = [NSMutableString stringWithString:value];
} else if (propertyClass == [NSMutableData class] && [value isKindOfClass:[NSData class]]) {
    value = [NSMutableData dataWithData:value];
}

if (!type.isFromFoundation && propertyClass) { // 模型属性
    // 既不是基础类型，也不是NS类型。即：基本数据类型
    value = [propertyClass mj_objectWithKeyValues:value context:context];
} else if (objectClass) {
    if (objectClass == [NSURL class] && [value isKindOfClass:[NSArray class]]) {
        // string array -> url array
        NSMutableArray *urlArray = [NSMutableArray array];
        for (NSString *string in value) {
            if (![string isKindOfClass:[NSString class]]) continue;
            [urlArray addObject:string.mj_url];
        }
        value = urlArray;
    } else { // 字典数组-->模型数组
        value = [objectClass mj_objectArrayWithKeyValuesArray:value context:context];
    }
} else if (propertyClass == [NSString class]) {


} else if ([value isKindOfClass:[NSString class]]) {

} else if ([value isKindOfClass:[NSNumber class]] && propertyClass == [NSDecimalNumber class]){

}

// 经过转换后, 最终检查 value 与 property 是否匹配
if (propertyClass && ![value isKindOfClass:propertyClass]) {
    value = nil;
}
[property setValue:value forObject:self];

/**
 *  设置成员变量的值
 */
- (void)setValue:(id)value forObject:(id)object
{
    if (self.type.KVCDisabled || value == nil) return;
    [object setValue:value forKey:self.name];
}

// 转换并返回模型中所有属性的键值对
- (NSMutableDictionary *)mj_keyValues;

/**
 @para keys 需要返回的特定键的数组
 @return 特定关键词的键值对
 */
- (NSMutableDictionary *)mj_keyValuesWithKeys:(NSArray *)keys;

/**
 @para ignoredKeys 需要忽略的特定键的数组
 @return 除特定关键词的其他有效键值对
 */
- (NSMutableDictionary *)mj_keyValuesWithIgnoredKeys:(NSArray *)ignoredKeys;

// 白名单
if (allowedPropertyNames.count && ![allowedPropertyNames containsObject:property.name]) return;
// 黑名单
if ([ignoredPropertyNames containsObject:property.name]) return;
// 只需要返回的特定键
if (keys.count && ![keys containsObject:property.name]) return;
// 需要被忽略的特定键
if ([ignoredKeys containsObject:property.name]) return;

id value = [property valueForObject:self];

/**
 *  获得成员变量的值
 */
- (id)valueForObject:(id)object
{
    if (self.type.KVCDisabled) return [NSNull null];

    id value = [object valueForKey:self.name];

    // 32位BOOL类型转换json后成Int类型
    /** https://github.com/CoderMJLee/MJExtension/issues/545 */
    // 32 bit device OR 32 bit Simulator
#if defined(__arm__) || (TARGET_OS_SIMULATOR && !__LP64__)
    if (self.type.isBoolType) {
        value = @([(NSNumber *)value boolValue]);
    }
#endif

    return value;
}

MJPropertyType *type = property.type;
Class propertyClass = type.typeClass;
if (!type.isFromFoundation && propertyClass) {
    value = [value mj_keyValues];
} else if ([value isKindOfClass:[NSArray class]]) {
    // 3.处理数组里面有模型的情况
    value = [NSObject mj_keyValuesArrayWithObjectArray:value];
} else if (propertyClass == [NSURL class]) {
    value = [value absoluteString];
}

keyValues[property.name] = value;

// 获取原始key
NSArray *propertyKeys = [[property propertyKeysForClass:clazz] firstObject];
NSUInteger keyCount = propertyKeys.count;
// 创建字典
__block id innerContainer = keyValues;
[propertyKeys enumerateObjectsUsingBlock:^(MJPropertyKey *propertyKey, NSUInteger idx, BOOL *stop) {
    // 下一个属性
    MJPropertyKey *nextPropertyKey = nil;
    if (idx != keyCount - 1) {
        nextPropertyKey = propertyKeys[idx + 1];
    }

    if (nextPropertyKey) { // 不是最后一个key
        // 当前propertyKey对应的字典或者数组
        id tempInnerContainer = [propertyKey valueInObject:innerContainer];
        if (tempInnerContainer == nil || [tempInnerContainer isKindOfClass:[NSNull class]]) {
            if (nextPropertyKey.type == MJPropertyKeyTypeDictionary) {
                tempInnerContainer = [NSMutableDictionary dictionary];
            } else {
                tempInnerContainer = [NSMutableArray array];
            }
            if (propertyKey.type == MJPropertyKeyTypeDictionary) {
                innerContainer[propertyKey.name] = tempInnerContainer;
            } else {
                innerContainer[propertyKey.name.intValue] = tempInnerContainer;
            }
        }

        if ([tempInnerContainer isKindOfClass:[NSMutableArray class]]) {
            NSMutableArray *tempInnerContainerArray = tempInnerContainer;
            int index = nextPropertyKey.name.intValue;
            while (tempInnerContainerArray.count < index + 1) {
                [tempInnerContainerArray addObject:[NSNull null]];
            }
        }

        innerContainer = tempInnerContainer;
    } else { // 最后一个key
        if (propertyKey.type == MJPropertyKeyTypeDictionary) {
            innerContainer[propertyKey.name] = value;
        } else {
            innerContainer[propertyKey.name.intValue] = value;
        }
    }
}];

// JSON|字典 转 模型
+ (nullable instancetype)yy_modelWithJSON:(id)json;
+ (nullable instancetype)yy_modelWithDictionary:(NSDictionary *)dictionary;

// 通过 JSON|字典 为 模型赋值
- (BOOL)yy_modelSetWithJSON:(id)json;
- (BOOL)yy_modelSetWithDictionary:(NSDictionary *)dic;

// 模型转JSON
- (NSString *)yy_modelToJSONString;

// JSON数组转模型数组
+ (nullable NSArray *)yy_modelArrayWithClass:(Class)cls json:(id)json;

/**
 通过一组 键-值对(NSDictionary)，创建和返回一个新的实例
 此方法是线程安全的。

 @参数： dictionary  一组能够映射实例属性的 键-值对(dictionary)
 无效的键值对将会被忽略。

 @返回： 一个通过 键-值对(dictionary) 创建的新实例，出错的情况下返回nil。

 @说明： 字典中的 key 和 value 将分别映射在模型的属性名，和属性值上。
 如果值得类型不发与属性相匹配，此方法将尝试根据如下规则，进行转化：

     `NSString` or `NSNumber` -> c number, such as BOOL, int, long, float, NSUInteger...
     `NSString` -> NSDate, parsed with format "yyyy-MM-dd'T'HH:mm:ssZ", "yyyy-MM-dd HH:mm:ss" or "yyyy-MM-dd".
     `NSString` -> NSURL.
     `NSValue` -> struct or union, such as CGRect, CGSize, ...
     `NSString` -> SEL, Class.
 */

+ (instancetype)yy_modelWithDictionary:(NSDictionary *)dictionary {
    if (!dictionary || dictionary == (id)kCFNull) return nil;
    if (![dictionary isKindOfClass:[NSDictionary class]]) return nil;

    // 创建当前类的类对象实例
    Class cls = [self class];
    // 创建和获取 模型的元类（包含类的详细信息）
    _YYModelMeta *modelMeta = [_YYModelMeta metaWithClass:cls];

    // 判断使用者是否自定义 类的（子类）类型
    if (modelMeta->_hasCustomClassFromDictionary) {
        cls = [cls modelCustomClassForDictionary:dictionary] ?: cls;
    }

    // 创建实例实例
    NSObject *one = [cls new];

    // 为属性赋值
    if ([one yy_modelSetWithDictionary:dictionary]) return one;
    return nil;
}

/// 模型对象的类元信息
@interface _YYModelMeta : NSObject {
    @package
    YYClassInfo *_classInfo;
    /// Key:mapped key and key path, Value:_YYModelPropertyMeta.  数据结构：{"pic": [_YYModelPropertyMeta new]}
    NSDictionary *_mapper;
    /// Array<_YYModelPropertyMeta>, 所有有效属性元的数组
    NSArray *_allPropertyMetas;
    /// Array<_YYModelPropertyMeta>, 映射到键值路径的属性元
    NSArray *_keyPathPropertyMetas;
    /// Array<_YYModelPropertyMeta>, 映射到多个键的属性元
    NSArray *_multiKeysPropertyMetas;
    /// 有效的键值对数量，所谓有效即包含 _getter、_setter、成员变量。 值与 _mapper.count 相同
    NSUInteger _keyMappedCount;
    /// 数据类型
    YYEncodingNSType _nsType;

    BOOL _hasCustomWillTransformFromDictionary;
    BOOL _hasCustomTransformFromDictionary;
    BOOL _hasCustomTransformToDictionary;
    BOOL _hasCustomClassFromDictionary;
}
@end

@class YYCircle, YYRectangle, YYLine;

@implementation YYShape

+ (Class)modelCustomClassForDictionary:(NSDictionary*)dictionary {
    if (dictionary[@"radius"] != nil) {
        return [YYCircle class];
    } else if (dictionary[@"width"] != nil) {
        return [YYRectangle class];
    } else if (dictionary[@"y2"] != nil) {
        return [YYLine class];
    } else {
        return [self class];
    }
}
@end

NSObject *one = [cls new];

- (BOOL)yy_modelSetWithDictionary:(NSDictionary *)dic {
    if (!dic || dic == (id)kCFNull) return NO;
    if (![dic isKindOfClass:[NSDictionary class]]) return NO;

    // 创建和获取 模型的元类（包含类的详细信息）
    _YYModelMeta *modelMeta = [_YYModelMeta metaWithClass:object_getClass(self)];

    // 判断当前类的有效属性数量
    if (modelMeta->_keyMappedCount == 0) return NO;

    // 判断使用者是否自定义了转换映射
    if (modelMeta->_hasCustomWillTransformFromDictionary) {
        dic = [((id<YYModel>)self) modelCustomWillTransformFromDictionary:dic];
        if (![dic isKindOfClass:[NSDictionary class]]) return NO;
    }

    // 创建 模型设置上下文
    ModelSetContext context = {0};
    context.modelMeta = (__bridge void *)(modelMeta);
    context.model = (__bridge void *)(self);
    context.dictionary = (__bridge void *)(dic); //dic or json

    //  比较 元模型的键值数量 & 传入字典的键值数量
    if (modelMeta->_keyMappedCount >= CFDictionaryGetCount((CFDictionaryRef)dic)) {
        /**
         @function CFDictionaryApplyFunction
         对字典中的每个键值对调用函数一次。

         @param  theDict
         要查的字典。

         @param  applier
         要对字典中的每个值调用一次的回调函数。

         @param context
         一个指针大小的用户定义值，作为第三个参数传递给applier函数，但此函数不使用它。

         */
        CFDictionaryApplyFunction((CFDictionaryRef)dic, ModelSetWithDictionaryFunction, &context);

        if (modelMeta->_keyPathPropertyMetas) {
            CFArrayApplyFunction((CFArrayRef)modelMeta->_keyPathPropertyMetas,
                                 CFRangeMake(0, CFArrayGetCount((CFArrayRef)modelMeta->_keyPathPropertyMetas)),
                                 ModelSetWithPropertyMetaArrayFunction,
                                 &context);
        }
        if (modelMeta->_multiKeysPropertyMetas) {
            CFArrayApplyFunction((CFArrayRef)modelMeta->_multiKeysPropertyMetas,
                                 CFRangeMake(0, CFArrayGetCount((CFArrayRef)modelMeta->_multiKeysPropertyMetas)),
                                 ModelSetWithPropertyMetaArrayFunction,
                                 &context);
        }
    } else {
        /**
         @function CFArrayApplyFunction
         对数组中的每个元素调用函数一次。

         @param theArray
         要操作的数组。

         @param range
         要将函数应用于的数组中的值范围。

         @param applier
         对数组中给定范围内的每个值调用一次的回调函数。如果此参数不是指向正确原型的函数的指针，则行为未定义。如果在应用程序函数期望的范围内存在或不能正确应用的值，则该行为是未定义的。

         @param context
         一个指针大小的用户定义值，它作为第二个参数传递给applier函数，但此函数不使用它。如果上下文不是applier函数所期望的内容，则行为是未定义的。

         */
        CFArrayApplyFunction((CFArrayRef)modelMeta->_allPropertyMetas,
                             CFRangeMake(0, modelMeta->_keyMappedCount),
                             ModelSetWithPropertyMetaArrayFunction,
                             &context);
    }

    if (modelMeta->_hasCustomTransformFromDictionary) {
        return [((id<YYModel>)self) modelCustomTransformFromDictionary:dic];
    }
    return YES;
}

typedef struct {
    void *modelMeta;  ///< _YYModelMeta 类元
    void *model;      ///< id (self) 实例本身
    void *dictionary; ///< NSDictionary (json) 数据字典（json）
} ModelSetContext;

static void ModelSetValueForProperty(__unsafe_unretained id model,// 实例对象
                                     __unsafe_unretained id value,// 值
                                     __unsafe_unretained _YYModelPropertyMeta *meta //属性元
                                     )

- (id)yy_modelToJSONObject {
    /*
     Apple said:
     The top level object is an NSArray or NSDictionary.
     All objects are instances of NSString, NSNumber, NSArray, NSDictionary, or NSNull.
     All dictionary keys are instances of NSString.
     Numbers are not NaN or infinity.
     */
    id jsonObject = ModelToJSONObjectRecursive(self);
    if ([jsonObject isKindOfClass:[NSArray class]]) return jsonObject;
    if ([jsonObject isKindOfClass:[NSDictionary class]]) return jsonObject;
    return nil;
}

- (NSData *)yy_modelToJSONData {
    id jsonObject = [self yy_modelToJSONObject];
    if (!jsonObject) return nil;
    return [NSJSONSerialization dataWithJSONObject:jsonObject options:0 error:NULL];
}

- (NSString *)yy_modelToJSONString {
    NSData *jsonData = [self yy_modelToJSONData];
    if (jsonData.length == 0) return nil;
    return [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
}

if (!model || model == (id)kCFNull) return model;
if ([model isKindOfClass:[NSString class]]) return model;
if ([model isKindOfClass:[NSNumber class]]) return model;
if ([model isKindOfClass:[NSURL class]]) return ((NSURL *)model).absoluteString;
if ([model isKindOfClass:[NSAttributedString class]]) return ((NSAttributedString *)model).string;
if ([model isKindOfClass:[NSDate class]]) return [YYISODateFormatter( ) stringFromDate:(id)model];
if ([model isKindOfClass:[NSData class]]) return nil;

// 字典
if ([model isKindOfClass:[NSDictionary class]]) {
    if ([NSJSONSerialization isValidJSONObject:model]) return model;
    NSMutableDictionary *newDic = [NSMutableDictionary new];
    [((NSDictionary *)model) enumerateKeysAndObjectsUsingBlock:^(NSString *key, id obj, BOOL *stop) {
        NSString *stringKey = [key isKindOfClass:[NSString class]] ? key : key.description;
        if (!stringKey) return;
        id jsonObj = ModelToJSONObjectRecursive(obj);
        if (!jsonObj) jsonObj = (id)kCFNull;
        newDic[stringKey] = jsonObj;
    }];
    return newDic;
}

// 集合
if ([model isKindOfClass:[NSSet class]]) {
    NSArray *array = ((NSSet *)model).allObjects;
    if ([NSJSONSerialization isValidJSONObject:array]) return array;
    NSMutableArray *newArray = [NSMutableArray new];
    for (id obj in array) {
        if ([obj isKindOfClass:[NSString class]] || [obj isKindOfClass:[NSNumber class]]) {
            [newArray addObject:obj];
        } else {
            id jsonObj = ModelToJSONObjectRecursive(obj);
            if (jsonObj && jsonObj != (id)kCFNull) [newArray addObject:jsonObj];
        }
    }
    return newArray;
}

// 数组
if ([model isKindOfClass:[NSArray class]]) {
    if ([NSJSONSerialization isValidJSONObject:model]) return model;
    NSMutableArray *newArray = [NSMutableArray new];
    for (id obj in (NSArray *)model) {
        if ([obj isKindOfClass:[NSString class]] || [obj isKindOfClass:[NSNumber class]]) {
            [newArray addObject:obj];
        } else {
            id jsonObj = ModelToJSONObjectRecursive(obj);
            if (jsonObj && jsonObj != (id)kCFNull) [newArray addObject:jsonObj];
        }
    }
    return newArray;
}

// 自定义类
_YYModelMeta *modelMeta = [_YYModelMeta metaWithClass:[model class]];
if (!modelMeta || modelMeta->_keyMappedCount == 0) return nil;
NSMutableDictionary *result = [[NSMutableDictionary alloc] initWithCapacity:64];
__unsafe_unretained NSMutableDictionary *dic = result; // avoid retain and release in block
[modelMeta->_mapper enumerateKeysAndObjectsUsingBlock:^(NSString *propertyMappedKey, _YYModelPropertyMeta *propertyMeta, BOOL *stop) {
    if (!propertyMeta->_getter) return;

    id value = nil;
    if (propertyMeta->_isCNumber) {
        value = ModelCreateNumberFromProperty(model, propertyMeta);
    } else if (propertyMeta->_nsType) {
        id v = ((id (*)(id, SEL))(void *) objc_msgSend)((id)model, propertyMeta->_getter);
        value = ModelToJSONObjectRecursive(v);
    } else {
        switch (propertyMeta->_type & YYEncodingTypeMask) {
            case YYEncodingTypeObject: {
                id v = ((id (*)(id, SEL))(void *) objc_msgSend)((id)model, propertyMeta->_getter);
                value = ModelToJSONObjectRecursive(v);
                if (value == (id)kCFNull) value = nil;
            } break;
            case YYEncodingTypeClass: {
                Class v = ((Class (*)(id, SEL))(void *) objc_msgSend)((id)model, propertyMeta->_getter);
                value = v ? NSStringFromClass(v) : nil;
            } break;
            case YYEncodingTypeSEL: {
                SEL v = ((SEL (*)(id, SEL))(void *) objc_msgSend)((id)model, propertyMeta->_getter);
                value = v ? NSStringFromSelector(v) : nil;
            } break;
            default: break;
        }
    }
    if (!value) return;

    if (propertyMeta->_mappedToKeyPath) {
        NSMutableDictionary *superDic = dic;
        NSMutableDictionary *subDic = nil;
        for (NSUInteger i = 0, max = propertyMeta->_mappedToKeyPath.count; i < max; i++) {
            NSString *key = propertyMeta->_mappedToKeyPath[i];
            if (i + 1 == max) { // end
                if (!superDic[key]) superDic[key] = value;
                break;
            }

            subDic = superDic[key];
            if (subDic) {
                if ([subDic isKindOfClass:[NSDictionary class]]) {
                    subDic = subDic.mutableCopy;
                    superDic[key] = subDic;
                } else {
                    break;
                }
            } else {
                subDic = [NSMutableDictionary new];
                superDic[key] = subDic;
            }
            superDic = subDic;
            subDic = nil;
        }
    } else {
        if (!dic[propertyMeta->_mappedToKey]) {
            dic[propertyMeta->_mappedToKey] = value;
        }
    }
}];

if (modelMeta->_hasCustomTransformToDictionary) {
    // 校验数据
    BOOL suc = [((id<YYModel>)model) modelCustomTransformToDictionary:dic];
    if (!suc) return nil;
}
return result;