the runtime （二）

这两个函数，一个是拷贝一个新的对象，一个是释放对象，但都不支持ARC。。。。

 

　　OBJC_EXPORT Class object_setClass(id obj, Class cls) 

     　　__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);

改变成新的class并返回旧的class

OBJC_EXPORT const char *object_getClassName(id obj)

    __OSX_AVAILABLE_STARTING(__MAC_10_0, __IPHONE_2_0);

获取class

 

OBJC_EXPORT const char *object_getClassName(id obj)

    __OSX_AVAILABLE_STARTING(__MAC_10_0, __IPHONE_2_0);

获取类名，不过是const char

 向一个类动态添加方法

 BOOL class_addMethod(Class cls, SEL name, IMP imp, const char *types)

 参数说明：

 cls：被添加方法的类

 name：可以理解为方法名

 imp：实现这个方法的函数

 types：一个定义该函数返回值类型和参数类型的字符串

 class_addMethod([TestClass class], @selector(ocMethod:), (IMP)testFunc, "i@:@");

 

 其中types参数为"i@:@“，按顺序分别表示：

 i：返回值类型int，若是v则表示void

 @：参数id(self)

 :：SEL(_cmd)

 @：id(str)

获取一个类的所有方法
- (void) getClassAllMethod
{
    u_int count;
    Method* methods= class_copyMethodList([UIViewController class], &count); //获取该类方法列表和方法数量
    for (int i = 0; i < count ; i++)
    {
        SEL name = method_getName(methods[i]);//获取方法
        NSString *strName = [NSString stringWithCString:sel_getName(name)encoding:NSUTF8StringEncoding];//输出方法名
        NSLog(@"%@",strName);
    }
}

获取一个类的所有属性：
- (void) propertyNameList
{
    u_int count;
    objc_property_t *properties=class_copyPropertyList([UIViewControllerclass], &count);//取属性列表
    for (int i = 0; i < count ; i++)
    {
        const char* propertyName =property_getName(properties[i]);//取属性名
        NSString *strName = [NSString stringWithCString:propertyNameencoding:NSUTF8StringEncoding];
        NSLog(@"%@",strName);
    }
}

获取／设置类的属性变量
//获取全局变量的值   （myFloat 为类的一个属性变量）
- (void) getInstanceVar {
    float myFloatValue;
    object_getInstanceVariable(self,"myFloat", (void*)&myFloatValue);
    NSLog(@"%f", myFloatValue);
}
//设置全局变量的值
- (void) setInstanceVar {
    float newValue = 10.00f;
    unsigned int addr = (unsignedint)&newValue;
    object_setInstanceVariable(self,"myFloat", *(float**)addr);
    NSLog(@"%f", myFloat);
}

判断类的某个属性的类型
- (void) getVarType {
    ClassCustomClass *obj = [ClassCustomClass new];
    Ivar var = class_getInstanceVariable(object_getClass(obj),"varTest1"); //这的两个参数，一个是对象，一个是属性的名字（字符串）
    const char* typeEncoding =ivar_getTypeEncoding(var);
    NSString *stringType =  [NSStringstringWithCString:typeEncodingencoding:NSUTF8StringEncoding];
    
    if ([stringType hasPrefix:@"@"]) {
        // 如果是对象
        NSLog(@"handle class case");
    } else if ([stringTypehasPrefix:@"i"]) {
        // 整型
        NSLog(@"handle int case");
    } else if ([stringTypehasPrefix:@"f"]) {
        // 浮点
        NSLog(@"handle float case");
    } else
    {
 
    }
}

通过属性的值来获取其属性的名字（反射机制）
- (NSString *)nameOfInstance:(id)instance
{
    unsigned int numIvars =0;
    NSString *key=nil;
    
    //Describes the instance variables declared by a class. 
    Ivar * ivars = class_copyIvarList([ClassCustomClassclass], &numIvars);//获取全部的Ivar
    
    for(int i = 0; i < numIvars; i++) {
        Ivar thisIvar = ivars[i];
        
        const char *type =ivar_getTypeEncoding(thisIvar);//挨个取出来
        NSString *stringType =  [NSStringstringWithCString:typeencoding:NSUTF8StringEncoding];
        
        //不是class就跳过
        if (![stringType hasPrefix:@"@"]) {
            continue;
        }
        
        //Reads the value of an instance variable in an object. object_getIvar这个方法中，当遇到非objective-c对象时，并直接crash
        if ((object_getIvar(allobj, thisIvar) == instance)) {
            // Returns the name of an instance variable.
            key = [NSStringstringWithUTF8String:ivar_getName(thisIvar)];
            break;
        }
    }
    free(ivars);
    return key;
}

系统类的方法实现部分替换
- (void) methodExchange {
    Method m1 = class_getInstanceMethod([NSString class],@selector(lowercaseString));
    Method m2 = class_getInstanceMethod([NSString class],@selector(uppercaseString));
    method_exchangeImplementations(m1, m2);//方法名给换了，小写变大写，大写变小写
    NSLog(@"%@", [@"sssAAAAss" lowercaseString]);
    NSLog(@"%@", [@"sssAAAAss" uppercaseString]);
}

自定义类的方法实现部分替换
- (void) justLog1 {
    NSLog(@"justLog1");
}
- (void) justLog2 {
    NSLog(@"justLog2");
}
- (void) methodSetImplementation {
    Method method = class_getInstanceMethod([ClassMethodViewCtr class],@selector(justLog1));
    IMP originalImp = method_getImplementation(method);(关于IMP不明白的看（一）)
    Method m1 = class_getInstanceMethod([ClassMethodViewCtr class],@selector(justLog2));
    method_setImplementation(m1, originalImp);//替换justLog2，相当于改变了justLog2的函数指针，前面的是被替换的参数，后面的替换的参数
}
在执行justLog2方法，实际执行的是justLog1

重写类的方法(Overriding Methods)

Overriding methods在任何面向对象语言中都很常见，主要用于子类化中。在子类中复写一个方法，然后在子类的实例就可以使用这个被重写的方法。
对于一个你无法控制其实例化(instantiation)的类，有时你或许会想复写它的某个方法，虽然有点疯狂。子类化可做不到，因为你没有机会子类化你的子类。

类目(Categories)

使用类目(category)的技术,可以方便地为一个已经存在的类复写其方法:

    @implementationNSView(MyOverride)

    

    - (void)drawRect: (NSRect)r

    { www.2cto.com

        // 这个会替换掉通常使用的-[NSView drawRect:]

        [[NSColor blueColor]set];

        NSRectFill(r);

    }

    @end

这种方法其实仅仅适用于复写目标类的父类中实现的函数。如果直接复写目标类中的方法，使用类目会带来两个问题:

它无法调用方法的之前的实现。替换掉后，之前的实现就被完全改写了。但大部分情况下，只是想增加些功能，并不期望完全替代

如果被多个category复写，运行时(runtime)并不保证哪个真正会被使用到。

/****************************************************************************************/

使用一个称为swizzling的技术，可以为归类(category)解决上面两个问题，既可以调用旧的实现，又可以避免多个category带来的不确定性。它的秘诀是使用一个不同的函数名来复写，然后由运行时(runtime)交换它们。

首先，用一个不同的名字复写:

    @implementationNSView(MyOverride)

   

    - (void)override_drawRect: (NSRect)r

    {

        // 调用旧的实现。因为它们已经被替换了

        [self override_drawRect: r];

       

        [[NSColor blueColor]set];

        NSRectFill(r);

    }

    @end

(译注:呵呵，不知道你是不是和我一样，初次看到代码还以为是个递归调用呢。) 其实是这个新的方法在执行时已经和原先的函数对调了（现在还没做到，往下看！）。在运行时，调用 override_drawRect: 方法其实就是调用旧的实现。

接下来，你还要写些代码才能完成交换:

    void MethodSwizzle(Class c,SEL origSEL,SEL overrideSEL)

    {

        Method origMethod = class_getInstanceMethod(c, origSEL);

        Method overrideMethod= class_getInstanceMethod(c, overrideSEL);

周全起见，有两种情况要考虑一下。

第一种情况是要复写的方法(overridden)并没有在目标类中实现(notimplemented)，而是在其父类中实现了。

第二种情况是这个方法已经存在于目标类中(does existin the class itself)。这两种情况要区别对待。

 (译注: 这个地方有点要明确一下，它的目的是为了使用一个重写的方法替换掉原来的方法。但重写的方法可能是在父类中重写的，也可能是在子类中重写的。)

 

 对于第一种情况，应当先在目标类增加一个新的实现方法(override)，然后将复写的方法替换为原先(的实现(original one)。

 

运行时函数class_addMethod 如果发现方法已经存在，会失败返回，也可以用来做检查用:

        if(class_addMethod(c, origSEL, method_getImplementation(overrideMethod),method_getTypeEncoding(overrideMethod)))

        {

 

如果添加成功(在父类中重写的方法)，再把目标类中的方法替换为旧有的实现:

            class_replaceMethod(c,overrideSEL, method_getImplementation(origMethod), method_getTypeEncoding(origMethod));

        }

 

(译注:addMethod会让目标类的方法指向新的实现，使用replaceMethod再将新的方法指向原先的实现，这样就完成了交换操作。)

 

如果添加失败了，就是第二情况(在目标类重写的方法)。这时可以通过method_exchangeImplementations来完成交换:

        else

        {

            method_exchangeImplementations(origMethod,overrideMethod);

        }

    }

对于第二种情况，因为class_getInstanceMethod 会返回父类的实现，如果直接替换，就会替换掉父类的实现，而不是目标类中的实现。

举个具体的例子, 假设要替换掉-[NSView description]. 如果NSView 没有实现-description (可选的) 那你就可会得到NSObject的方法。如果调用method_exchangeImplementations , 你就会把NSObject 的方法替换成你的代码。这应该不会是你想要的吧？

 

最后在一个合适位置调用一下就可以了。比如在一个+load 方法中调用:

    + (void)load

    {

        MethodSwizzle(self,@selector(drawRect:),@selector(override_drawRect:));

    }

看到这里，比较糊里糊涂的，但是呢，实际就和注解的一样，就是相当于重写了以前所存在的一个方法，至于那种类似递归的写法，其实就是相当于在调用原来的方法，这个涉及到runtime的东西有点绕，可以这样去理解，就是当要执行这个方法的时候，这个方法的指针已经不是原来指定的那个方法块了，例：A是原来的方法a，B是自己写的方法b，B所要做的事情就是在A的基础上还要另外做一些附加的事情。那么写法就是类似递归的那种写法了，B自己调用自己b(写法是这样实际不是)，但是实际在运行时，方法a，也就是原方法是要执行的，因为和b方法调换了，系统会去执行方法b，而b方法因为里面写的要执行自己的方法b，而这个时候的方法实际为a，于是也就满足了在原来的方法上续写的目的。绕啊绕的。。。。。

开始还有点不容易理解的地方，就是他调用自己的时候，按照常理，他不就确实会调用自己么，但是不能忘了，这是在runtime下的，这2个方法已经被交换过了，目的是为了骗过编译器，让它执行的时候是执行你的方法而不是原来的方法。

为了实现这个么原方法之外的额外的操作，本来通过方法重写即可完成，但是，很多第三方封装的类，你想干个什么他都没有提供接口类方法什么的，你不就可以用这种方法来干了么。

不过这种方法，个人感觉很类似木马的捆绑。。。。够流氓，我喜欢

 

 

直接重写(Direct Override)

前面的内容确实有些难懂。Swizzling的概念的确显得有些古怪，特别是在函数中转来转去的，多少让人有些思维扭曲的感觉。我下面要介绍一个更为简洁，也更容易理解和实现的方式。

 

这种方式不再需要保存旧有的方法，也不必动态的区分[self override_drawRect: r] 。我们从头实现。

 

相对于将原有的方法存放于一个新的方法中，这里使用一个全局指针来保存:

    void (*gOrigDrawRect)(id,SEL, NSRect);

 

然后在+load 里赋值:

    + (void)load

    {

        Method origMethod = class_getInstanceMethod(self,@selector(drawRect:));

        gOrigDrawRect = (void*)method_getImplementation(origMethod);//method_getImplementation返回的是IMP，也就是函数指针，所以能够直接转换

(我喜欢把它转换为 void *，因为比那些又长又奇怪的函数指针好输入多了。)

 

然后像前面介绍的那样用新的实现替换掉就可以了。因为class_replaceMethod本身会尝试调用class_addMethod和method_setImplementation，所以直接调用class_replaceMethod就可以了。 

实现如下:

Method origMethod =class_getInstanceMethod(self, @selector(drawRect:)); 

gOrigDrawRect = (void *)class_replaceMethod(self,@selector(drawRect:), (IMP)OverrideDrawRect,method_getTypeEncoding(origMethod))

 

最后实现复写方法。和之前不同的是，这里是一个函数，而不是方法:

    static void OverrideDrawRect(NSView*self,SEL _cmd, NSRect r)

    {

        gOrigDrawRect(self,_cmd, r);

        [[NSColor blueColor]set];

        NSRectFill(r);

    }

当然，这个方法不是那么优雅，不过我认为它更易于运用。

//这个方法更粗暴，都不需要交换那样难以理解，直接取出原方法的IMP，然后用一个函数指针来存放，用自己的函数指针替换掉他的，在自己的方法里面去执行他那个函数指针所指向的方法，就是如此的简单粗暴，不错。

 http://blog.csdn.net/lizhongfu2013/article/details/9498233

最后这个网址是关于 用c实现OC。。。。。