@implementation UIViewController (Swizzling)

+ (void)load {
    [super load];
    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        
		SEL originalSelector = @selector(viewDidLoad);
		SEL swizzleSelector = @selector(dc_swizzlingViewDidLoad);
        
        Method originalMethod = class_getInstanceMethod([self class], originalSelector);
        Method swizzleMethod = class_getInstanceMethod([self class], swizzleSelector);
        
        BOOL didAddMethod = class_addMethod([self class],
                                            originalSelector,
                                            method_getImplementation(swizzleMethod),
                                            method_getTypeEncoding(swizzleMethod));
        
        if (didAddMethod) {
            class_replaceMethod([self class],
                                swizzleSelector,
                                method_getImplementation(originalMethod),
                                method_getTypeEncoding(originalMethod));
        }else{
            method_exchangeImplementations(originalMethod, swizzleMethod);
        }
    });
}
// 和viewDidLoad方法进行交换的方法
- (void)dc_swizzlingViewDidLoad {
    NSString *str = [NSString stringWithFormat:@"%@", self.class];
    
    // 我们在这里加一个判断，将系统的UIViewController的对象剔除掉
    if(![str containsString:@"UI"]){
        NSLog(@"swizzlingViewDidLoad___统计打点 : %@", self.class);
    }
    
    //这里使用dc_swizzlingViewDidLoad是不会产生递归调用的, 因为方法已经互换, 所以这里调用的是其实是viewDidLoad
    [self dc_swizzlingViewDidLoad];
}

- (void)customBaseMethod
{
    NSLog(@"custom base method has invoked");
}

@end

/** 
* Returns a specified instance method for a given class.
* 
* @param cls The class you want to inspect.
* @param name The selector of the method you want to retrieve.
* 
* @return The method that corresponds to the implementation of the selector specified by 
*  \e name for the class specified by \e cls, or \c NULL if the specified class or its 
*  superclasses do not contain an instance method with the specified selector.
*
* @note This function searches superclasses for implementations, whereas \c class_copyMethodList does not.
*/

/** 
* Adds a new method to a class with a given name and implementation.
* 
* @param cls The class to which to add a method.
* @param name A selector that specifies the name of the method being added.
* @param imp A function which is the implementation of the new method. The function must take at least two arguments—self and _cmd.
* @param types An array of characters that describe the types of the arguments to the method. 
* 
* @return YES if the method was added successfully, otherwise NO 
*  (for example, the class already contains a method implementation with that name).
*
* @note class_addMethod will add an override of a superclass's implementation, 
*  but will not replace an existing implementation in this class. 
*  To change an existing implementation, use method_setImplementation.
*/

/** 
* Replaces the implementation of a method for a given class.
* 
* @param cls The class you want to modify.
* @param name A selector that identifies the method whose implementation you want to replace.
* @param imp The new implementation for the method identified by name for the class identified by cls.
* @param types An array of characters that describe the types of the arguments to the method. 
*  Since the function must take at least two arguments—self and _cmd, the second and third characters
*  must be “@:” (the first character is the return type).
* 
* @return The previous implementation of the method identified by \e name for the class identified by \e cls.
* 
* @note This function behaves in two different ways:
*  - If the method identified by \e name does not yet exist, it is added as if \c class_addMethod were called. 
*    The type encoding specified by \e types is used as given.
*  - If the method identified by \e name does exist, its \c IMP is replaced as if \c method_setImplementation were called.
*    The type encoding specified by \e types is ignored.
*/

/** 
* Exchanges the implementations of two methods.
* 
* @param m1 Method to exchange with second method.
* @param m2 Method to exchange with first method.
* 
* @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
*/

+ (BOOL)swizzleMethod:(SEL)originSelector withMethod:(SEL)swizzleSelector {
    Method originMethod = class_getInstanceMethod(self, originSelector);
    if (!originMethod) {
        return NO;
    }

    Method swizzleMethod = class_getInstanceMethod(self, swizzleSelector);
    if (!swizzleMethod) {
        return NO;
    }

    class_addMethod(self,
                    originSelector,
                    class_getMethodImplementation(self, originSelector),
                    method_getTypeEncoding(originMethod));

    class_addMethod(self,
                    swizzleSelector,
                    class_getMethodImplementation(self, swizzleSelector),
                    method_getTypeEncoding(swizzleMethod));

    method_exchangeImplementations(class_getInstanceMethod(self, originSelector), class_getInstanceMethod(self, swizzleSelector));

    return YES;
}