OC拥有很多的动态特性,这些动态特性在运行程序时发挥作用,而不是在编译或者链接代码时发挥作用.这一特性,也为OC提供了很多强大的功能和灵活性. 比如可以以实时的方式进行程序的开发和更新,而不需要重新编译或者重新部署.
运行时系统的基本应用
对象消息
在面向对象中呢,消息传递是指在对象之间发送和接收消息. 在OC中的对象消息传递用于类和对象方法的调用.
[接收器 方法选择器:(参数)];
接收器就是class或者obj. 消息就是由 selecter 和 parameter构成. 对象消息的传递是以动态的方式实现的. 接收器的相应类型和相应的调用方法,是在运行时决定的(所以会存在一些与动态绑定有关的额外开销,当然oc有缓存机制来减少这种开销).
所以OC对象消息传递的关键要素有:
.接收器:类,对象
.消息:选择器+参数
. 方法:声明方法的实现,参数,返回值等等....
. 方法绑定. 向接收器发送消息的时候,寻找并且执行方法的过程
选择器
在消息传递的过程中,选择器是一个文本字符串.
` -(void)addValue1:(NSInteger)value1 value2:(NSInteger)value2{...}`
`addValue1:value2:`
选择器是一个特殊的类型.
SEL类型 是用于在编写源代码时替换选择器值的标识符.
- (void)viewDidLoad {
[super viewDidLoad];
// SEL addValue1 = NSSelectorFromString(@"addvalue1:value2:");
SEL addValue1 = @selector(addvalue1:value2:);
//[self addvalue1:@"a" value2:@"b"];
[self performSelector:addValue1 withObject:@"a" withObject:@"b"];
}
-(void)addvalue1:(NSString *)value1 value2:(NSString *)value2
{
NSLog(@"%@",NSStringFromSelector(_cmd));
//addvalue1:value2:
}
动态类型 和 对象内省
运行时系统通过动态类型(dynamic typing)功能可以在运行程序时,决定对象的类型.
id类型是一个OC所特有的类型,它的变量可以存储任意类型的对象.
id list = [NSArray new];
list = @"I am a sting";
if([list isKindOfClass:[NSArray class]]){}
if([list isKindOfClass:[NSString class]]){}
好处就是可以简化接口,提供非常大的灵活性.
动态绑定(dynamic binding)
是指在运行程序时(而不是编译)将消息与方法对应起来的处理过程.在运行程序和发送消息前,消息和接收消息的对象不会对应. 因为许多的接收器可能实现了相同的方法,调用方式会动态变化.动态绑定实现了 OOP的多态性.
id person = [[People alloc]init];
[person run];
因为person的类型为 People,运行时系统会搜寻 People的run方法. 如果没有找到,就去父类中寻找对相应方法.直到找到为止.
OC运行时系统 确定消息接收器的类型(动态类型)-> 然后确定实现的方法(动态绑定)->调用方法.
动态方法决议
动态方法决议能够以动态的方法实现方法. 通过
+(BOOL)resolveClassMethod:(SEL)sel
+(BOOL)resolveInstanceMethod:(SEL)sel
Description: Dynamically provides an implementation for a given selector for an instance method.
This method and resolveClassMethod: allow you to dynamically provide an implementation for a given selector.
An Objective-C method is simply a C function that take at least two arguments—self and _cmd. Using the class_addMethod function, you can add a function to a class as a method. Given the following function:
parameters: name The name of a selector to resolve.
return: YES if the method was found and added to the receiver, otherwise NO.
以动态的方式,添加类方法,或者实例方法.
void doLogin(){
NSLog(@"dologin");
}
@implementation ViewController
+(BOOL)resolveInstanceMethod:(SEL)sel
{
NSString *string = NSStringFromSelector(sel);
if ([string isEqualToString:@"doLogin"]) {
class_addMethod([self class], sel, (IMP)doLogin,"@@:@");
return YES;
}
return [super resolveInstanceMethod:sel];
}
- (void)viewDidLoad {
[super viewDidLoad];
[self performSelector:NSSelectorFromString(@"doLogin")];
}
/// A pointer to the function of a method implementation.
#if !OBJC_OLD_DISPATCH_PROTOTYPES
typedef void (*IMP)(void /* id, SEL, ... */ );
#else
typedef id (*IMP)(id, SEL, ...);
#endif
"@@:@" OC的类型编码
-(id)forwardingTargetForSelector:(SEL)aSelector
Returns the object to which unrecognized messages should first be directed.
If an object implements (or inherits) this method, and returns a non-nil (and non-self) result, that returned object is used as the new receiver object and the message dispatch resumes to that new object.
NSInteger a = [self performSelector:NSSelectorFromString(@"length")];
}
-(id)forwardingTargetForSelector:(SEL)aSelector
{
if ([NSStringFromSelector(aSelector) isEqualToString:@"length"]) {
return @"没有找到方法";
}
return 0;
}
运行时系统的结构
介绍运行时系统的结构以及它实现这些动态特性的方式.
运行时系统的组成部分
OC的运行时系统由两个部分组成:编译器 和 运行时系统库
编译器
在编译阶段,编译器对源文件进行一系列的处理(预处理,词法分析,语法分析,链接...)等.生成构成可执行程序的二进制文件. 运行时系统会为OC的面向对象特征提供标准的API和实现代码. OC的面向对象元素和动态特性,都是由运行时系统提供的.
运行时系统由这几部分组成:
类元素:接口,实现代码,协议,分类,方法,属性,变量等等
类实例: 对象
对象消息的传递: 动态类型,动态绑定
动态方法决议
动态加载
对象内省
当编译器解析使用了这些元素和特性的OC源码时,它就会使用适当的运行时系统库数据结构和函数,生成可执行代码.例子:
- 生成对象消息传递代码
[接收器 消息];
它会生成调用运行时系统库中函数 objc_msgSend()的代码.将源码转化为objc_msgSend(..)的代码,每条消息都是以动态的方式处理的,这就意味着接收器的类型和方法的实际实现,都是在运行程序的时候决定的.
OBJC_EXPORT id objc_msgSend(id self, SEL op, ...)
OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0);
- 生成类和代码
/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class;
/// Represents an instance of a class.
struct objc_object {
Class isa OBJC_ISA_AVAILABILITY;
};
Class的数据类型就是一个 objc_class 结构体指针
struct objc_class {
Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
Class super_class OBJC2_UNAVAILABLE;
const char *name OBJC2_UNAVAILABLE;
long version OBJC2_UNAVAILABLE;
long info OBJC2_UNAVAILABLE;
long instance_size OBJC2_UNAVAILABLE;
struct objc_ivar_list *ivars OBJC2_UNAVAILABLE;
struct objc_method_list **methodLists OBJC2_UNAVAILABLE;
struct objc_cache *cache OBJC2_UNAVAILABLE;
struct objc_protocol_list *protocols OBJC2_UNAVAILABLE;
#endif
} OBJC2_UNAVAILABLE;
运行时库提供接口,访问这些信息:
objc_getClass(const char *name); // 对象的类定义
objc_getMetaClass(const char *name); // 对象的元类定义
class_getSuperclass(__unsafe_unretained Class cls); // 类的父类
class_copyMethodList(__unsafe_unretained Class cls, unsigned int *outCount); // 类的方法列表
class_copyIvarList(__unsafe_unretained Class cls, unsigned int *outCount)//实例变量列表
class_copyPropertyList(__unsafe_unretained Class cls, unsigned int *outCount);// 属性列表
id 类型的定义
typedef struct objc_object *id;
运行时系统库
运行时系统库提供的有公开API,这些API使用C语言编写.例如:
- 使用运行时系统创建类.
NSString* hello(){
return @"hello world";
}
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// 创建一个类
Class dynaClass = objc_allocateClassPair([NSObject class], "DynaClass", 0);
// 给类添加一个方法
class_addMethod(dynaClass, @selector(firstMethod), (IMP)hello, "@@:@");
objc_registerClassPair(dynaClass);
id dynaObj = [[dynaClass alloc]init];
id result = [dynaObj performSelector:@selector(firstMethod)];
NSLog(@"%@",result);
}
2.实现运行时系统的对象消息传递
运行时系统定义了一种方法数据类型(objc_method)
struct objc_method {
SEL method_name // SEL类型的变量
char *method_types
IMP method_imp // IMP的变量 方法的函数地址
}
typedef struct objc_method *Method;
执行方法的逻辑:
1.通过对象的isa指针,找到对象所属的类
2.通过搜索类的方法缓存,查找方法的IMP指针.如果找到了,就去调用函数.
- 类的方法列表
- 一系列的动态方法决议方法.
- 父类的方法列表
与运行时系统的交互
- 运行时系统api. C风格的.
- NSObject提供了一套api.其他类继承NSObject.
isKindOfClass..
performerSelect...
运行时系统的应用
AFN里的方法混淆
+ (void)swizzleResumeAndSuspendMethodForClass:(Class)theClass {
Method afResumeMethod = class_getInstanceMethod(self, @selector(af_resume));
Method afSuspendMethod = class_getInstanceMethod(self, @selector(af_suspend));
if (af_addMethod(theClass, @selector(af_resume), afResumeMethod)) {
af_swizzleSelector(theClass, @selector(resume), @selector(af_resume));
}
if (af_addMethod(theClass, @selector(af_suspend), afSuspendMethod)) {
af_swizzleSelector(theClass, @selector(suspend), @selector(af_suspend));
}
}
// AFN
static inline void af_swizzleSelector(Class theClass, SEL originalSelector, SEL swizzledSelector) {
Method originalMethod = class_getInstanceMethod(theClass, originalSelector);
Method swizzledMethod = class_getInstanceMethod(theClass, swizzledSelector);
method_exchangeImplementations(originalMethod, swizzledMethod);
}
- (void)af_suspend {
NSAssert([self respondsToSelector:@selector(state)], @"Does not respond to state");
NSURLSessionTaskState state = [self state];
[self af_suspend]; // 方法交换后 [self suspend]; 挂起,结束
if (state != NSURLSessionTaskStateSuspended) {
// dataTask suspend 后发送通知
[[NSNotificationCenter defaultCenter] postNotificationName:AFNSURLSessionTaskDidSuspendNotification object:self];
}
}
//
* @note This is an atomic version of the following:
* \code
* IMP imp1 = method_getImplementation(m1);
* IMP imp2 = method_getImplementation(m2);
* method_setImplementation(m1, imp2);
* method_setImplementation(m2, imp1);
* \endcode
*/
OBJC_EXPORT void method_exchangeImplementations(Method m1, Method m2)
OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0);
YYModel
// 属性列表
objc_property_t *properties = class_copyPropertyList(cls, &propertyCount);
if (properties) {
NSMutableDictionary *propertyInfos = [NSMutableDictionary new];
_propertyInfos = propertyInfos;
for (unsigned int i = 0; i < propertyCount; i++) {
YYClassPropertyInfo *info = [[YYClassPropertyInfo alloc] initWithProperty:properties[i]];
if (info.name) propertyInfos[info.name] = info;
}
free(properties);
}
- (instancetype)initWithProperty:(objc_property_t)property {
if (!property) return nil;
self = [super init];
_property = property;
const char *name = property_getName(property);
if (name) {
_name = [NSString stringWithUTF8String:name];
}
YYEncodingType type = 0;
unsigned int attrCount;
objc_property_attribute_t *attrs = property_copyAttributeList(property, &attrCount);
for (unsigned int i = 0; i < attrCount; i++) {
switch (attrs[i].name[0]) {
case 'T': { // Type encoding
if (attrs[i].value) {
...
case 'v': return YYEncodingTypeVoid | qualifier;
case 'B': return YYEncodingTypeBool | qualifier;
case 'c': return YYEncodingTypeInt8 | qualifier;
case 'C': return YYEncodingTypeUInt8 | qualifier;
case 's': return YYEncodingTypeInt16 | qualifier;
case 'S': return YYEncodingTypeUInt16 | qualifier;
case 'i': return YYEncodingTypeInt32 | qualifier;
case 'I': return YYEncodingTypeUInt32 | qualifier;
case 'l': return YYEncodingTypeInt32 | qualifier;
case 'L': return YYEncodingTypeUInt32 | qualifier;
case 'q': return YYEncodingTypeInt64 | qualifier;
case 'Q': return YYEncodingTypeUInt64 | qualifier;
case 'f': return YYEncodingTypeFloat | qualifier;
case 'd': return YYEncodingTypeDouble | qualifier;
case 'D': return YYEncodingTypeLongDouble | qualifier;
}
....
case 'R': {
type |= YYEncodingTypePropertyReadonly;
} break;
case 'C': {
type |= YYEncodingTypePropertyCopy;
} break;
case '&': {
type |= YYEncodingTypePropertyRetain;
} break;
case 'N': {
type |= YYEncodingTypePropertyNonatomic;
} break;
case 'D': {
type |= YYEncodingTypePropertyDynamic;
} break;
-----------------------完----------------------