首页 星云 工具 资源 星选 资讯 热门工具
:

PDF转图片 完全免费 小红书视频下载 无水印 抖音视频下载 无水印 数字星空

iOS开发基础133-崩溃预防

编程知识
2024年07月18日 16:24

现代移动应用的用户体验依赖于其稳定性和可靠性。然而，在开发过程中，我们时常会遇到各种崩溃问题。崩溃不仅会影响用户的使用体验，还可能损害应用的声誉。因此，本文将详细介绍一个名为CrashPrevention的工具类，它能够为iOS开发者提供多方面的崩溃预防措施，借助该工具类，开发者能够有效减少崩溃的发生，并提升应用的稳定性。

CrashPrevention工具类概述

CrashPrevention是一个易于集成的工具类，专为iOS应用中的多种常见崩溃情况提供预防措施。通过调用相关方法，开发者可以开启针对数组操作、字典操作、未识别的选择器、通知中心、键值观察（KVO）、字符串操作、多线程操作以及UI线程操作的保护机制。特别值得一提的是，CrashPrevention让开发者可以通过一个全局的 isDebug 标志，灵活控制是否启用这些崩溃预防措施。

CrashPrevention.h 头文件

首先，我们来看一下CrashPrevention的头文件，其中定义了所有的预防方法：

#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>

@interface CrashPrevention : NSObject

// 设置是否在 Debug 模式中启用崩溃预防
+ (void)setDebugMode:(BOOL)isDebug;

// 启用所有崩溃保护
+ (void)enableAllCrashPrevention;

// 启用各类崩溃保护
+ (void)enableArrayProtection;
+ (void)enableDictionaryProtection;
+ (void)enableSelectorProtection;
+ (void)enableNotificationProtection;
+ (void)enableKVOCrashProtection;
+ (void)enableStringProtection;
+ (void)enableThreadSafetyProtection;
+ (void)enableUIThreadProtection;

@end

CrashPrevention.m 实现文件

接下来，我们深入了解实现文件的设计思路和具体代码。

全局Debug标志

@implementation CrashPrevention

// 用于记录是否在 Debug 模式下启用崩溃预防
static BOOL debugModeEnabled = NO;

// 设置是否在 Debug 模式中启用崩溃预防
+ (void)setDebugMode:(BOOL)isDebug {
    debugModeEnabled = isDebug;
}

通过 static BOOL debugModeEnabled，我们可以记录是否启用调试模式，基于此标志决定是否启用崩溃预防功能。

启用所有崩溃保护

+ (void)enableAllCrashPrevention {
    if (!debugModeEnabled) {
        return;
    }
    [self enableArrayProtection];
    [self enableDictionaryProtection];
    [self enableSelectorProtection];
    [self enableNotificationProtection];
    [self enableKVOCrashProtection];
    [self enableStringProtection];
    [self enableThreadSafetyProtection];
    [self enableUIThreadProtection];
}

该方法通过检查 debugModeEnabled 标志，决定是否依次启用各类崩溃保护。

数组越界保护

+ (void)enableArrayProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:NSClassFromString(@"__NSArrayI")
                           original:@selector(objectAtIndex:)
                           swizzled:@selector(safe_objectAtIndex:)];
        [self swizzleInstanceMethod:NSClassFromString(@"__NSArrayM")
                           original:@selector(objectAtIndex:)
                           swizzled:@selector(safe_objectAtIndex:)];
    });
}

- (id)safe_objectAtIndex:(NSUInteger)index {
    if (index < self.count) {
        return [self safe_objectAtIndex:index];
    } else {
        @try {
            NSLog(@"Array index out of bound: %lu", (unsigned long)index);
        } @catch (NSException *exception) {
            // 处理异常
        }
        return nil;
    }
}

通过 Method Swizzling，我们可以将数组的 objectAtIndex: 方法替换为安全版本。在越界的情况下，返回 nil 并记录日志，而不会崩溃。

字典键值检查保护

+ (void)enableDictionaryProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:NSClassFromString(@"__NSDictionaryI")
                           original:@selector(objectForKey:)
                           swizzled:@selector(safe_objectForKey:)];
    });
}

- (id)safe_objectForKey:(id)key {
    if (key) {
        return [self safe_objectForKey:key];
    } else {
        @try {
            NSLog(@"Attempted to access dictionary with nil key");
        } @catch (NSException *exception) {
            // 处理异常
        }
        return nil;
    }
}

类似地，通过 Method Swizzling，我们可以将 objectForKey: 方法替换为安全版本，防止使用 nil 作为键值时的崩溃。

消息转发保护

+ (void)enableSelectorProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Method forwardMethod = class_getInstanceMethod([self class], @selector(forwardingMethod:));
        class_addMethod([self class], NSSelectorFromString(@"unrecognizedSelectorHandler"), method_getImplementation(forwardMethod), method_getTypeEncoding(forwardMethod));
    });
}

- (void)forwardingMethod:(SEL)aSelector {}

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    if (!debugModeEnabled) {
        return [super resolveInstanceMethod:sel];
    }
    class_addMethod([self class], sel, class_getMethodImplementation([self class], @selector(forwardingMethod:)), "v@:");
    return YES;
}

通过添加一个默认的 forwardingMethod: ，我们防止调用未实现的方法时崩溃。

通知中心保护

+ (void)enableNotificationProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:[NSNotificationCenter class]
                           original:@selector(addObserver:selector:name:object:)
                           swizzled:@selector(safe_addObserver:selector:name:object:)];
        [self swizzleInstanceMethod:[NSNotificationCenter class]
                           original:@selector(removeObserver:name:object:)
                           swizzled:@selector(safe_removeObserver:name:object:)];
    });
}

- (void)safe_addObserver:(NSObject *)observer selector:(SEL)aSelector name:(NSString *)aName object:(id)anObject {
    if (observer) {
        [[NSNotificationCenter defaultCenter] safe_addObserver:observer selector:aSelector name:aName object:anObject];
    } else {
        @try {
            NSLog(@"Attempted to add a nil observer for name: %@", aName);
        } @catch (NSException *exception) {
            // 处理异常
        }
    }
}

- (void)safe_removeObserver:(NSObject *)observer name:(NSString *)aName object:(id)anObject {
    if (observer) {
        [[NSNotificationCenter defaultCenter] safe_removeObserver:observer name:aName object:anObject];
    } else {
        @try {
            NSLog(@"Attempted to remove a nil observer for name: %@", aName);
        } @catch (NSException *exception) {
            // 处理异常
        }
    }
}

在添加和移除观察者时进行空检查，防止空观察者导致的崩溃。

KVO 保护

+ (void)enableKVOCrashProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:[NSObject class]
                           original:@selector(addObserver:forKeyPath:options:context:)
                           swizzled:@selector(safe_addObserver:forKeyPath:options:context:)];
        [self swizzleInstanceMethod:[NSObject class]
                           original:@selector(removeObserver:forKeyPath:)
                           swizzled:@selector(safe_removeObserver:forKeyPath:)];
    });
}

- (void)safe_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(void *)context {
    if (observer && keyPath) {
        [self safe_addObserver:observer forKeyPath:keyPath options:options context:context];
    } else {
        @try {
            NSLog(@"Attempted to add observer with nil observer or key path: %@", keyPath);
        } @catch (NSException *exception) {
            // 处理异常
        }
    }
}

- (void)safe_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath {
    if (observer && keyPath) {
        [self safe_removeObserver:observer forKeyPath:keyPath];
    } else {
        @try {
            NSLog(@"Attempted to remove observer with nil observer or key path: %@", keyPath);
        } @catch (NSException *exception) {
            // 处理异常
        }
    }
}

在添加和移除KVO时进行必要检查，确保参数合法，防止崩溃。

字符串越界检查

+ (void)enableStringProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:NSClassFromString(@"__NSCFConstantString")
                           original:@selector(substringFromIndex:)
                           swizzled:@selector(safe_substringFromIndex:)];
    });
}

- (NSString *)safe_substringFromIndex:(NSUInteger)from {
    if (from <= self.length) {
        return [self safe_substringFromIndex:from];
    } else {
        @try {
            NSLog(@"String index out of bound: %lu", (unsigned long)from);
        } @catch (NSException *exception) {
            // 处理异常
        }
        return nil;
    }
}

通过交换NSString的相关方法，确保在越界访问时返回 nil 并记录日志，从而避免崩溃。

线程安全保护

+ (void)enableThreadSafetyProtection {
    if (!debugModeEnabled) {
        return;
    }
    // 实现是与具体使用场景相关的，需要结合项目实际情况实现
}

这部分的实现高度依赖于具体的使用场景，比如可以使用 dispatch_barrier_async、NSLock 等技术实现。

UI线程保护

+ (void)enableUIThreadProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:[UIView class]
                           original:@selector(setNeedsLayout)
                           swizzled:@selector(safe_setNeedsLayout)];
    });
}

- (void)safe_setNeedsLayout {
    if ([NSThread isMainThread]) {
        [self safe_setNeedsLayout];
    } else {
        dispatch_async(dispatch_get_main_queue(), ^{
            [self safe_setNeedsLayout];
        });
        @try {
            NSLog(@"setNeedsLayout was called off the main thread. Fixed by dispatching to main queue.");
        } @catch (NSException *exception) {
            // 处理异常
        }
    }
}

确保UI操作总在主线程进行，如果不是，则调度到主线程执行，并记录警告日志。

方法交换

#pragma mark - Method Swizzling
+ (void)swizzleInstanceMethod:(Class)cls original:(SEL)originalSelector swizzled:(SEL)swizzledSelector {
    Method originalMethod = class_getInstanceMethod(cls, originalSelector);
    Method swizzledMethod = class_getInstanceMethod(cls, swizzledSelector);

    BOOL didAddMethod = class_addMethod(cls, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
    if (didAddMethod) {
        class_replaceMethod(cls, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
    } else {
        method_exchangeImplementations(originalMethod, swizzledMethod);
    }
}
@end

核心方法交换逻辑，通过 Method Swizzling 替换原有的方法实现。

使用CrashPrevention工具类

在应用启动时初始化CrashPrevention，并设置是否启用调试模式：

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // 设置 Debug 模式
    #ifdef DEBUG
        [CrashPrevention setDebugMode:YES];
    #else
        [CrashPrevention setDebugMode:NO];
    #endif
    
    [CrashPrevention enableAllCrashPrevention];
    return YES;
}

总结

CrashPrevention工具类为iOS开发者提供了多个方面的崩溃预防措施，通过简单调用，即可为数组、字典、未识别选择器、通知中心、KVO、字符串、多线程和UI线程的操作提供全面的保护。特别是通过 isDebug 标志，让开发者可以灵活控制这些预防措施在调试阶段和正式发布中的启用状态。借助这一工具类，开发者能够有效减少崩溃问题的发生，提升应用的稳定性和用户体验。

最后附上完整代码：

CrashPrevention.h文件

#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>

@interface CrashPrevention : NSObject

// 设置是否在 Debug 模式中启用崩溃预防
+ (void)setDebugMode:(BOOL)isDebug;

// 启用所有崩溃保护
+ (void)enableAllCrashPrevention;

// 启用各类崩溃保护
+ (void)enableArrayProtection;
+ (void)enableDictionaryProtection;
+ (void)enableSelectorProtection;
+ (void)enableNotificationProtection;
+ (void)enableKVOCrashProtection;
+ (void)enableStringProtection;
+ (void)enableThreadSafetyProtection;
+ (void)enableUIThreadProtection;

@end

CrashPrevention.m文件

#import "CrashPrevention.h"
#import <objc/runtime.h>

@implementation CrashPrevention

// 用于记录是否在 Debug 模式下启用崩溃预防
static BOOL debugModeEnabled = NO;

// 设置是否在 Debug 模式中启用崩溃预防
+ (void)setDebugMode:(BOOL)isDebug {
    debugModeEnabled = isDebug;
}

// 启用所有崩溃保护
+ (void)enableAllCrashPrevention {
    if (!debugModeEnabled) {
        return;
    }
    [self enableArrayProtection];
    [self enableDictionaryProtection];
    [self enableSelectorProtection];
    [self enableNotificationProtection];
    [self enableKVOCrashProtection];
    [self enableStringProtection];
    [self enableThreadSafetyProtection];
    [self enableUIThreadProtection];
}

#pragma mark - Array Protection
+ (void)enableArrayProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:NSClassFromString(@"__NSArrayI")
                           original:@selector(objectAtIndex:)
                           swizzled:@selector(safe_objectAtIndex:)];
        [self swizzleInstanceMethod:NSClassFromString(@"__NSArrayM")
                           original:@selector(objectAtIndex:)
                           swizzled:@selector(safe_objectAtIndex:)];
    });
}

- (id)safe_objectAtIndex:(NSUInteger)index {
    if (index < self.count) {
        return [self safe_objectAtIndex:index];
    } else {
        @try {
            NSLog(@"Array index out of bound: %lu", (unsigned long)index);
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            return nil;
        }
    }
}

#pragma mark - Dictionary Protection
+ (void)enableDictionaryProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:NSClassFromString(@"__NSDictionaryI")
                           original:@selector(objectForKey:)
                           swizzled:@selector(safe_objectForKey:)];
        [self swizzleInstanceMethod:NSClassFromString(@"__NSDictionaryM")
                           original:@selector(objectForKey:)
                           swizzled:@selector(safe_objectForKey:)];
    });
}

- (id)safe_objectForKey:(id)key {
    if (key) {
        return [self safe_objectForKey:key];
    } else {
        @try {
            NSLog(@"Attempted to access dictionary with nil key");
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            return nil;
        }
    }
}

#pragma mark - Selector Protection
+ (void)enableSelectorProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Method forwardMethod = class_getInstanceMethod([self class], @selector(forwardingMethod:));
        class_addMethod([self class], NSSelectorFromString(@"unrecognizedSelectorHandler"), method_getImplementation(forwardMethod), method_getTypeEncoding(forwardMethod));
    });
}

- (void)forwardingMethod:(SEL)aSelector {}

+ (BOOL)resolveInstanceMethod:(SEL)sel {
    if (!debugModeEnabled) {
        return [super resolveInstanceMethod:sel];
    }
    class_addMethod([self class], sel, class_getMethodImplementation([self class], @selector(forwardingMethod:)), "v@:");
    return YES;
}

#pragma mark - Notification Protection
+ (void)enableNotificationProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:[NSNotificationCenter class]
                           original:@selector(addObserver:selector:name:object:)
                           swizzled:@selector(safe_addObserver:selector:name:object:)];
        [self swizzleInstanceMethod:[NSNotificationCenter class]
                           original:@selector(removeObserver:name:object:)
                           swizzled:@selector(safe_removeObserver:name:object:)];
        [self swizzleInstanceMethod:[NSNotificationCenter class]
                           original:@selector(removeObserver:)
                           swizzled:@selector(safe_removeObserver:)];
    });
}

- (void)safe_addObserver:(NSObject *)observer selector:(SEL)aSelector name:(NSString *)aName object:(id)anObject {
    if (observer) {
        [[NSNotificationCenter defaultCenter] safe_addObserver:observer selector:aSelector name:aName object:anObject];
    } else {
        @try {
            NSLog(@"Attempted to add a nil observer for name: %@", aName);
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            // 什么也不做
        }
    }
}

- (void)safe_removeObserver:(NSObject *)observer {
    if (observer) {
        [[NSNotificationCenter defaultCenter] safe_removeObserver:observer];
    } else {
        @try {
            NSLog(@"Attempted to remove a nil observer");
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            // 什么也不做
        }
    }
}

- (void)safe_removeObserver:(NSObject *)observer name:(NSString *)aName object:(id)anObject {
    if (observer) {
        [[NSNotificationCenter defaultCenter] safe_removeObserver:observer name:aName object:anObject];
    } else {
        @try {
            NSLog(@"Attempted to remove a nil observer for name: %@", aName);
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            // 什么也不做
        }
    }
}

#pragma mark - KVO Protection
+ (void)enableKVOCrashProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:[NSObject class]
                           original:@selector(addObserver:forKeyPath:options:context:)
                           swizzled:@selector(safe_addObserver:forKeyPath:options:context:)];
        [self swizzleInstanceMethod:[NSObject class]
                           original:@selector(removeObserver:forKeyPath:)
                           swizzled:@selector(safe_removeObserver:forKeyPath:)];
    });
}

- (void)safe_addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(void *)context {
    if (observer && keyPath) {
        [self safe_addObserver:observer forKeyPath:keyPath options:options context:context];
    } else {
        @try {
            NSLog(@"Attempted to add observer with nil observer or key path: %@", keyPath);
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            // 什么也不做
        }
    }
}

- (void)safe_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath {
    if (observer && keyPath) {
        [self safe_removeObserver:observer forKeyPath:keyPath];
    } else {
        @try {
            NSLog(@"Attempted to remove observer with nil observer or key path: %@", keyPath);
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            // 什么也不做
        }
    }
}

#pragma mark - String Protection
+ (void)enableStringProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:NSClassFromString(@"__NSCFConstantString")
                           original:@selector(substringFromIndex:)
                           swizzled:@selector(safe_substringFromIndex:)];
        [self swizzleInstanceMethod:NSClassFromString(@"__NSCFConstantString")
                           original:@selector(substringToIndex:)
                           swizzled:@selector(safe_substringToIndex:)];
        [self swizzleInstanceMethod:NSClassFromString(@"__NSCFConstantString")
                           original:@selector(substringWithRange:)
                           swizzled:@selector(safe_substringWithRange:)];
    });
}

- (NSString *)safe_substringFromIndex:(NSUInteger)from {
    if (from <= self.length) {
        return [self safe_substringFromIndex:from];
    } else {
        @try {
            NSLog(@"String index out of bound: %lu", (unsigned long)from);
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            return nil;
        }
    }
}

- (NSString *)safe_substringToIndex:(NSUInteger)to {
    if (to <= self.length) {
        return [self safe_substringToIndex:to];
    } else {
        @try {
            NSLog(@"String index out of bound: %lu", (unsigned long)to);
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            return nil;
        }
    }
}

- (NSString *)safe_substringWithRange:(NSRange)range {
    if (range.location + range.length <= self.length) {
        return [self safe_substringWithRange:range];
    } else {
        @try {
            NSLog(@"String range out of bound: %@", NSStringFromRange(range));
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            return nil;
        }
    }
}

#pragma mark - Thread Safety Protection
+ (void)enableThreadSafetyProtection {
    if (!debugModeEnabled) {
        return;
    }
    // 实现是与具体使用场景相关的，需要结合项目实际情况实现
}

#pragma mark - UI Thread Protection
+ (void)enableUIThreadProtection {
    if (!debugModeEnabled) {
        return;
    }
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self swizzleInstanceMethod:[UIView class]
                           original:@selector(setNeedsLayout)
                           swizzled:@selector(safe_setNeedsLayout)];
        [self swizzleInstanceMethod:[UIView class]
                           original:@selector(setNeedsDisplay)
                           swizzled:@selector(safe_setNeedsDisplay)];
        [self swizzleInstanceMethod:[UIView class]
                           original:@selector(setNeedsDisplayInRect:)
                           swizzled:@selector(safe_setNeedsDisplayInRect:)];
    });
}

- (void)safe_setNeedsLayout {
    if ([NSThread isMainThread]) {
        [self safe_setNeedsLayout];
    } else {
        dispatch_async(dispatch_get_main_queue(), ^{
            [self safe_setNeedsLayout];
        });
        @try {
            NSLog(@"setNeedsLayout was called off the main thread. Fixed by dispatching to main queue.");
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            // 什么也不做
        }
    }
}

- (void)safe_setNeedsDisplay {
    if ([NSThread isMainThread]) {
        [self safe_setNeedsDisplay];
    } else {
        dispatch_async(dispatch_get_main_queue(), ^{
            [self safe_setNeedsDisplay];
        });
        @try {
            NSLog(@"setNeedsDisplay was called off the main thread. Fixed by dispatching to main queue.");
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            // 什么也不做
        }
    }
}

- (void)safe_setNeedsDisplayInRect:(CGRect)rect {
    if ([NSThread isMainThread]) {
        [self safe_setNeedsDisplayInRect:rect];
    } else {
        dispatch_async(dispatch_get_main_queue(), ^{
            [self safe_setNeedsDisplayInRect:rect];
        });
        @try {
            NSLog(@"setNeedsDisplayInRect: was called off the main thread. Fixed by dispatching to main queue.");
        } @catch (NSException *exception) {
            // 处理异常
        } @finally {
            // 什么也不做
        }
    }
}

#pragma mark - Method Swizzling
+ (void)swizzleInstanceMethod:(Class)cls original:(SEL)originalSelector swizzled:(SEL)swizzledSelector {
    Method originalMethod = class_getInstanceMethod(cls, originalSelector);
    Method swizzledMethod = class_getInstanceMethod(cls, swizzledSelector);

    BOOL didAddMethod = class_addMethod(cls, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
    if (didAddMethod) {
        class_replaceMethod(cls, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
    } else {
        method_exchangeImplementations(originalMethod, swizzledMethod);
    }
}

@end
From:https://www.cnblogs.com/chglog/p/18310066
本文地址: http://www.shuzixingkong.net/article/160
0评论
提交 加载更多评论
其他文章 [MAUI 项目实战] 笔记App：程序设计
前言 有人说现在记事类app这么多，市场这么卷，为什么还想做一个笔记类App？ 一来，去年小孩刚出生，需要一个可以记录喂奶时间的app，发现市面上没有一款app能够在两步内简单记录一个时间，可能iOS可以通过备忘录配合捷径做到快速记录，但是安卓上就没有类似的app。 二是，自去年做的音乐播放器以来，
[MAUI 项目实战] 笔记App：程序设计 [MAUI 项目实战] 笔记App：程序设计 [MAUI 项目实战] 笔记App：程序设计
WPF使用AppBar实现窗口停靠，适配缩放、全屏响应和多窗口并列（附封装好即开即用的附加属性）
在吕毅大佬的文章中已经详细介绍了什么是AppBar:&#160;WPF 使用 AppBar 将窗口停靠在桌面上，让其他程序不占用此窗口的空间（附我封装的附加属性） - walterlv 即让窗口固定在屏幕某一边，并且保证其他窗口最大化后不会覆盖AppBar占据区域（类似于Windows任务栏）。 但
WPF使用AppBar实现窗口停靠，适配缩放、全屏响应和多窗口并列（附封装好即开即用的附加属性） WPF使用AppBar实现窗口停靠，适配缩放、全屏响应和多窗口并列（附封装好即开即用的附加属性） WPF使用AppBar实现窗口停靠，适配缩放、全屏响应和多窗口并列（附封装好即开即用的附加属性）
ComfyUI进阶：Comfyroll插件 (三)
前言： 学习ComfyUI是一场持久战，而Comfyroll 是一款功能强大的自定义节点集合，专为 ComfyUI 用户打造，旨在提供更加丰富和专业的图像生成与编辑工具。借助这些节点，用户可以在静态图像的精细调整和动态动画的复杂构建方面进行深入探索。Comfyroll 的节点设计简洁易用，功能强大，
ComfyUI进阶：Comfyroll插件 (三) ComfyUI进阶：Comfyroll插件 (三) ComfyUI进阶：Comfyroll插件 (三)
强烈推荐：18.3k star，推荐一款简单易用的HTTP请求流量录制回放工具：Goreplay
在软件开发和测试过程中，我们经常需要对应用程序的网络请求进行录制和回放，以便进行性能分析、压力测试或者模拟复杂的网络环境。今天，我要向大家推荐一款简单易用的 HTTP 请求流量录制回放工具：Goreplay。 1、简介 Goreplay 是一款用 Go 语言编写的 HTTP 请求流量录制回放工具。它
强烈推荐：18.3k star，推荐一款简单易用的HTTP请求流量录制回放工具：Goreplay 强烈推荐：18.3k star，推荐一款简单易用的HTTP请求流量录制回放工具：Goreplay
Linux 提权-NFS 共享
本文通过 Google 翻译 NFS Share no_root_squash – Linux Privilege Escalation 这篇文章所产生，本人仅是对机器翻译中部分表达别扭的字词进行了校正及个别注释补充。 导航 0 前言 1 什么是 NFS 共享？ 2 外部枚举 NFS 共享 2.1
Linux 提权-NFS 共享 Linux 提权-NFS 共享 Linux 提权-NFS 共享
反射快速入门
反射就是通过字节码文件获取类的成员变量、构造方法和成员方法的所有信息。 利用反射，我们可以获取成员变量的修饰符、名字、类型、取值。我们可以获取构造方法的名字、形参，并利用通过反射获取的构造方法创建对象。我们可以获取成员方法的修饰符、名字、形参、返回值、抛出的异常、注解，并运行通过反射获取的方法。 比
反射快速入门 为什么StampedLock会导致CPU100%？
StampedLock 是 Java 8 引入的一种高级的锁机制，它位于 java.util.concurrent.locks 包中。与传统的读写锁（ReentrantReadWriteLock）相比，StampedLock 提供了更灵活和更高性能的锁解决方案，尤其适用于读操作远多于写操作的场景。
 【漏洞分析】Li.Fi攻击事件分析：缺乏关键参数检查的钻石协议
背景信息 2024 年 7 月 16日，Li.Fi 协议遭受黑客攻击，漏洞成因是钻石协议中 diamond 合约新添加的 facet 合约没有对参数进行检查，导致 call 函数任意执行。且 diamond 合约拥有用户的 approve，所以攻击者可以构造恶意参数对用户资金进行转移。 攻击交易ht
【漏洞分析】Li.Fi攻击事件分析：缺乏关键参数检查的钻石协议 【漏洞分析】Li.Fi攻击事件分析：缺乏关键参数检查的钻石协议 【漏洞分析】Li.Fi攻击事件分析：缺乏关键参数检查的钻石协议
本站由星云主机提供云计算服务

网站建设一条龙服务、小程序开发、企业网站建设、定制开发，网络安全检测与维护 业务合作联系QQ:九六九五七三七