feat: sync httpdns sdk/platform updates without large binaries

2026-03-04 17:59:14 +08:00
parent 853897a6f8
commit 532891fad0
700 changed files with 6096 additions and 2712 deletions
--- a/HttpDNSSDK/sdk/ios/NewHttpDNS/HttpdnsRequestManager.m
+++ b/HttpDNSSDK/sdk/ios/NewHttpDNS/HttpdnsRequestManager.m
@@ -0,0 +1,645 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#import "HttpdnsRequestManager.h"
+#import "HttpdnsHostObject.h"
+#import "HttpdnsRemoteResolver.h"
+#import "HttpdnsLocalResolver.h"
+#import "HttpdnsInternalConstant.h"
+#import "HttpdnsUtil.h"
+#import "HttpdnsLog_Internal.h"
+#import "HttpdnsPersistenceUtils.h"
+#import "HttpdnsService_Internal.h"
+#import "HttpdnsScheduleCenter.h"
+#import "HttpdnsService_Internal.h"
+#import "HttpdnsReachability.h"
+#import "HttpdnsHostRecord.h"
+#import "HttpdnsUtil.h"
+#import "HttpDnsLocker.h"
+#import "HttpdnsRequest_Internal.h"
+#import "HttpdnsHostObjectInMemoryCache.h"
+#import "HttpdnsIPQualityDetector.h"
+#import "HttpdnsIpStackDetector.h"
+#import "HttpdnsDB.h"
+
+
+static dispatch_queue_t _persistentCacheConcurrentQueue = NULL;
+static dispatch_queue_t _asyncResolveHostQueue = NULL;
+
+typedef struct {
+    BOOL isResultUsable;
+    BOOL isResolvingRequired;
+} HostObjectExamingResult;
+
+@interface HttpdnsRequestManager()
+
+@property (nonatomic, strong) dispatch_queue_t cacheQueue;
+@property (nonatomic, assign, readwrite) NSInteger accountId;
+@property (nonatomic, weak) HttpDnsService *ownerService;
+
+@property (atomic, setter=setPersistentCacheIpEnabled:, assign) BOOL persistentCacheIpEnabled;
+@property (atomic, setter=setDegradeToLocalDNSEnabled:, assign) BOOL degradeToLocalDNSEnabled;
+@property (atomic, assign) BOOL atomicExpiredIPEnabled;
+@property (atomic, assign) BOOL atomicPreResolveAfterNetworkChanged;
+
+@property (atomic, assign) NSTimeInterval lastUpdateTimestamp;
+@property (atomic, assign) HttpdnsNetworkStatus lastNetworkStatus;
+
+@end
+
+@implementation HttpdnsRequestManager {
+    HttpdnsHostObjectInMemoryCache *_hostObjectInMemoryCache;
+    HttpdnsDB *_httpdnsDB;
+}
+
+ (void)initialize {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        _persistentCacheConcurrentQueue = dispatch_queue_create("com.Trust.sdk.httpdns.persistentCacheOperationQueue", DISPATCH_QUEUE_CONCURRENT);
+        _asyncResolveHostQueue = dispatch_queue_create("com.Trust.sdk.httpdns.asyncResolveHostQueue", DISPATCH_QUEUE_CONCURRENT);
+    });
+}
+
+- (instancetype)initWithAccountId:(NSInteger)accountId ownerService:(HttpDnsService *)service {
+    if (self = [super init]) {
+        _accountId = accountId;
+        _ownerService = service;
+
+        HttpdnsReachability *reachability = [HttpdnsReachability sharedInstance];
+        self.atomicExpiredIPEnabled = NO;
+        self.atomicPreResolveAfterNetworkChanged = NO;
+        _hostObjectInMemoryCache = [[HttpdnsHostObjectInMemoryCache alloc] init];
+        _httpdnsDB = [[HttpdnsDB alloc] initWithAccountId:accountId];
+        [[HttpdnsIpStackDetector sharedInstance] redetectIpStack];
+
+        _lastNetworkStatus = reachability.currentReachabilityStatus;
+        _lastUpdateTimestamp = [NSDate date].timeIntervalSince1970;
+
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(handleReachabilityNotification:)
+                                                     name:kHttpdnsReachabilityChangedNotification
+                                                   object:reachability];
+        [reachability startNotifier];
+    }
+    return self;
+}
+
+- (void)setExpiredIPEnabled:(BOOL)enable {
+    self.atomicExpiredIPEnabled = enable;
+}
+
+- (void)setCachedIPEnabled:(BOOL)enable discardRecordsHasExpiredFor:(NSTimeInterval)duration {
+    // 开启允许持久化缓存
+    [self setPersistentCacheIpEnabled:enable];
+
+    if (enable) {
+        dispatch_async(_persistentCacheConcurrentQueue, ^{
+            // 先清理过期时间超过阈值的缓存结果
+            [self->_httpdnsDB cleanRecordAlreadExpiredAt:[[NSDate date] timeIntervalSince1970] - duration];
+
+            // 再读取持久化缓存中的历史记录，加载到内存缓存<EFBFBD><EFBFBD>?
+            [self loadCacheFromDbToMemory];
+        });
+    }
+}
+
+- (void)setPreResolveAfterNetworkChanged:(BOOL)enable {
+    self.atomicPreResolveAfterNetworkChanged = enable;
+}
+
+- (void)preResolveHosts:(NSArray *)hosts queryType:(HttpdnsQueryIPType)queryType {
+    if (![HttpdnsUtil isNotEmptyArray:hosts]) {
+        return;
+    }
+
+    __weak typeof(self) weakSelf = self;
+    dispatch_async(_asyncResolveHostQueue, ^{
+        __strong typeof(weakSelf) strongSelf = weakSelf;
+        if (!strongSelf) {
+            return;
+        }
+
+        if ([strongSelf isHostsNumberLimitReached]) {
+            return;
+        }
+
+        // 分批处理，每批最<EFBFBD><EFBFBD>?个域<EFBFBD><EFBFBD>?
+        NSUInteger totalCount = hosts.count;
+        for (NSUInteger i = 0; i < totalCount; i += HTTPDNS_PRE_RESOLVE_BATCH_SIZE) {
+            NSUInteger length = MIN(HTTPDNS_PRE_RESOLVE_BATCH_SIZE, totalCount - i);
+            NSArray *batch = [hosts subarrayWithRange:NSMakeRange(i, length)];
+
+            NSString *combinedHostString = [batch componentsJoinedByString:@","];
+            HttpdnsLogDebug("Pre resolve host by async lookup, hosts: %@", combinedHostString);
+
+            HttpdnsRequest *request = [[HttpdnsRequest alloc] initWithHost:combinedHostString queryIpType:queryType];
+            request.accountId = strongSelf.accountId;
+            [request becomeNonBlockingRequest];
+
+            dispatch_async(_asyncResolveHostQueue, ^{
+                [strongSelf executePreResolveRequest:request retryCount:0];
+            });
+        }
+    });
+}
+
+#pragma mark - core method for all public query API
+- (HttpdnsHostObject *)resolveHost:(HttpdnsRequest *)request {
+    HttpdnsLogDebug("resolveHost, request: %@", request);
+
+    NSString *host = request.host;
+    NSString *cacheKey = request.cacheKey;
+
+    if (request.accountId == 0 || request.accountId != self.accountId) {
+        request.accountId = self.accountId;
+    }
+
+    if ([HttpdnsUtil isEmptyString:host]) {
+        return nil;
+    }
+
+    HttpdnsHostObject *result = [_hostObjectInMemoryCache getHostObjectByCacheKey:cacheKey createIfNotExists:^id _Nonnull {
+        HttpdnsLogDebug("No cache for cacheKey: %@", cacheKey);
+        HttpdnsHostObject *newObject = [HttpdnsHostObject new];
+        newObject.hostName = host;
+        newObject.v4Ips = @[];
+        newObject.v6Ips = @[];
+        return newObject;
+    }];
+
+    HostObjectExamingResult examingResult = [self examineHttpdnsHostObject:result underQueryType:request.queryIpType];
+    BOOL isCachedResultUsable = examingResult.isResultUsable;
+    BOOL isResolvingRequired = examingResult.isResolvingRequired;
+
+    if (isCachedResultUsable) {
+        if (isResolvingRequired) {
+            // 缓存结果可用，但是需要请求，因为缓存结果已经过期
+            // 这种情况异步去解析就可以<EFBFBD><EFBFBD>?
+            [self determineResolvingHostNonBlocking:request];
+        }
+        // 缓存是以cacheKey为准，这里返回前，要把host替换成用户请求的这个
+        result.hostName = host;
+        HttpdnsLogDebug("Reuse available cache for cacheKey: %@, result: %@", cacheKey, result);
+        // 因为缓存结果可用，可以立即返<EFBFBD><EFBFBD>?
+        return result;
+    }
+
+    if (request.isBlockingRequest) {
+        // 缓存结果不可用，且是同步请求，需要等待结<EFBFBD><EFBFBD>?
+        return [self determineResolveHostBlocking:request];
+    } else {
+        // 缓存结果不可用，且是异步请求，不需要等待结<EFBFBD><EFBFBD>?
+        [self determineResolvingHostNonBlocking:request];
+        return nil;
+    }
+}
+
+- (void)determineResolvingHostNonBlocking:(HttpdnsRequest *)request {
+    dispatch_async(_asyncResolveHostQueue, ^{
+        HttpDnsLocker *locker = [HttpDnsLocker sharedInstance];
+        if ([locker tryLock:request.cacheKey queryType:request.queryIpType]) {
+            @try {
+                [self executeRequest:request retryCount:0];
+            } @catch (NSException *exception) {
+                HttpdnsLogDebug("determineResolvingHostNonBlocking host: %@, exception: %@", request.host, exception);
+            } @finally {
+                [locker unlock:request.cacheKey queryType:request.queryIpType];
+            }
+        } else {
+            HttpdnsLogDebug("determineResolvingHostNonBlocking skipped due to concurrent limitation, host: %@", request.host);
+        }
+    });
+}
+
+- (HttpdnsHostObject *)determineResolveHostBlocking:(HttpdnsRequest *)request {
+    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+    __block HttpdnsHostObject *result = nil;
+    dispatch_async(_asyncResolveHostQueue, ^{
+        HttpDnsLocker *locker = [HttpDnsLocker sharedInstance];
+        @try {
+            [locker lock:request.cacheKey queryType:request.queryIpType];
+
+            result = [self->_hostObjectInMemoryCache getHostObjectByCacheKey:request.cacheKey];
+            if (result && ![result isExpiredUnderQueryIpType:request.queryIpType]) {
+                // 存在且未过期，意味着其他线程已经解析到了新的结果
+                return;
+            }
+
+            result = [self executeRequest:request retryCount:0];
+        } @catch (NSException *exception) {
+            HttpdnsLogDebug("determineResolveHostBlocking host: %@, exception: %@", request.host, exception);
+        } @finally {
+            [locker unlock:request.cacheKey queryType:request.queryIpType];
+            dispatch_semaphore_signal(semaphore);
+        }
+    });
+    dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, (int64_t)(request.resolveTimeoutInSecond * NSEC_PER_SEC)));
+    return result;
+}
+
+- (HostObjectExamingResult)examineHttpdnsHostObject:(HttpdnsHostObject *)hostObject underQueryType:(HttpdnsQueryIPType)queryType {
+    if (!hostObject) {
+        return (HostObjectExamingResult){NO, YES};
+    }
+
+    if ([hostObject isIpEmptyUnderQueryIpType:queryType]) {
+        return (HostObjectExamingResult){NO, YES};
+    }
+
+    if ([hostObject isExpiredUnderQueryIpType:queryType]) {
+        if (self.atomicExpiredIPEnabled || [hostObject isLoadFromDB]) {
+            // 只有开启了允许过期缓存，和开启持久化缓存情况下启动后加载到内存中的缓存，才可以直接复用过期结<EFBFBD><EFBFBD>?
+            HttpdnsLogDebug("The ips is expired, but we accept it, host: %@, queryType: %ld, expiredIpEnabled: %d, isLoadFromDB: %d",
+                            hostObject.hostName, queryType, self.atomicExpiredIPEnabled, [hostObject isLoadFromDB]);
+            // 复用过期结果，同时也需要发起新的解析请<EFBFBD><EFBFBD>?
+            return (HostObjectExamingResult){YES, YES};
+        }
+
+        // 只要过期了就肯定需要请<EFBFBD><EFBFBD>?
+        return (HostObjectExamingResult){NO, YES};
+    }
+
+    return (HostObjectExamingResult){YES, NO};
+}
+
+- (HttpdnsHostObject *)executeRequest:(HttpdnsRequest *)request retryCount:(int)hasRetryedCount {
+    NSString *host = request.host;
+    NSString *cacheKey = request.cacheKey;
+    HttpdnsQueryIPType queryIPType = request.queryIpType;
+    HttpdnsHostObject *result = nil;
+
+    BOOL isDegradationResult = NO;
+
+    if (hasRetryedCount <= HTTPDNS_MAX_REQUEST_RETRY_TIME) {
+        HttpdnsLogDebug("Internal request starts, host: %@, request: %@", host, request);
+
+        NSError *error = nil;
+        NSArray<HttpdnsHostObject *> *resultArray = [[HttpdnsRemoteResolver new] resolve:request error:&error];
+
+        if (error) {
+            HttpdnsLogDebug("Internal request error, host: %@, error: %@", host, error);
+
+            HttpdnsScheduleCenter *scheduleCenter = self.ownerService.scheduleCenter;
+            [scheduleCenter rotateServiceServerHost];
+
+            // 确保一定的重试间隔
+            hasRetryedCount++;
+            [NSThread sleepForTimeInterval:hasRetryedCount * 0.25];
+
+            return [self executeRequest:request retryCount:hasRetryedCount];
+        }
+
+        if ([HttpdnsUtil isEmptyArray:resultArray]) {
+            HttpdnsLogDebug("Internal request get empty result array, host: %@", host);
+            return nil;
+        }
+
+        // 这个路径里，host只会有一个，所以直接取第一个处理就<EFBFBD><EFBFBD>?
+        result = resultArray.firstObject;
+    } else {
+        if (!self.degradeToLocalDNSEnabled) {
+            HttpdnsLogDebug("Internal remote request retry count exceed limit, host: %@", host);
+            return nil;
+        }
+
+        result = [[HttpdnsLocalResolver new] resolve:request];
+        if (!result) {
+            HttpdnsLogDebug("Fallback to local dns resolver, but still get no result, host: %@", host);
+            return nil;
+        }
+
+        isDegradationResult = YES;
+    }
+
+    HttpdnsLogDebug("Internal request finished, host: %@, cacheKey: %@, isDegradationResult: %d, result: %@ ",
+                    host, cacheKey, isDegradationResult, result);
+
+    // merge之后，返回的应当是存储在缓存中的实际对象，而非请求过程中构造出来的对象
+    HttpdnsHostObject *lookupResult = [self mergeLookupResultToManager:result host:host cacheKey:cacheKey underQueryIpType:queryIPType];
+    // 返回一个快照，避免进行中的一些缓存调整影响返回去的结<EFBFBD><EFBFBD>?
+    return [lookupResult copy];
+}
+
+- (void)executePreResolveRequest:(HttpdnsRequest *)request retryCount:(int)hasRetryedCount {
+    NSString *host = request.host;
+    HttpdnsQueryIPType queryIPType = request.queryIpType;
+
+    BOOL isDegradationResult = NO;
+
+    if (hasRetryedCount > HTTPDNS_MAX_REQUEST_RETRY_TIME) {
+        HttpdnsLogDebug("PreResolve remote request retry count exceed limit, host: %@", host);
+        return;
+    }
+
+    HttpdnsLogDebug("PreResolve request starts, host: %@, request: %@", host, request);
+
+    NSError *error = nil;
+    NSArray<HttpdnsHostObject *> *resultArray = [[HttpdnsRemoteResolver new] resolve:request error:&error];
+
+    if (error) {
+        HttpdnsLogDebug("PreResolve request error, host: %@, error: %@", host, error);
+
+        HttpdnsScheduleCenter *scheduleCenter = self.ownerService.scheduleCenter;
+        [scheduleCenter rotateServiceServerHost];
+
+        // 确保一定的重试间隔
+        hasRetryedCount++;
+        [NSThread sleepForTimeInterval:hasRetryedCount * 0.25];
+
+        // 预解析重试需保持“多域名预解析”的语义，不能误用单域名执行路径
+        [self executePreResolveRequest:request retryCount:hasRetryedCount];
+
+        return;
+    }
+
+    if ([HttpdnsUtil isEmptyArray:resultArray]) {
+        HttpdnsLogDebug("PreResolve request get empty result array, host: %@", host);
+        return;
+    }
+
+    HttpdnsLogDebug("PreResolve request finished, host: %@, isDegradationResult: %d, result: %@ ",
+                    host, isDegradationResult, resultArray);
+
+    for (HttpdnsHostObject *result in resultArray) {
+        // merge之后，返回的应当是存储在缓存中的实际对象，而非请求过程中构造出来的对象
+        // 预解析不支持SDNS，所以cacheKey只能是单独的每一个hostName
+        [self mergeLookupResultToManager:result host:result.hostName cacheKey:result.hostName underQueryIpType:queryIPType];
+    }
+}
+
+- (HttpdnsHostObject *)mergeLookupResultToManager:(HttpdnsHostObject *)result host:host cacheKey:(NSString *)cacheKey underQueryIpType:(HttpdnsQueryIPType)queryIpType {
+    if (!result) {
+        return nil;
+    }
+
+    NSArray<HttpdnsIpObject *> *v4IpObjects = [result getV4Ips];
+    NSArray<HttpdnsIpObject *> *v6IpObjects = [result getV6Ips];
+    NSString* extra = [result getExtra];
+
+    BOOL hasNoIpv4Record = NO;
+    BOOL hasNoIpv6Record = NO;
+    if (queryIpType & HttpdnsQueryIPTypeIpv4 && [HttpdnsUtil isEmptyArray:v4IpObjects]) {
+        hasNoIpv4Record = YES;
+    }
+    if (queryIpType & HttpdnsQueryIPTypeIpv6 && [HttpdnsUtil isEmptyArray:v6IpObjects]) {
+        hasNoIpv6Record = YES;
+    }
+
+    HttpdnsHostObject *cachedHostObject = [_hostObjectInMemoryCache getHostObjectByCacheKey:cacheKey];
+    if (!cachedHostObject) {
+        HttpdnsLogDebug("Create new hostObject for cache, cacheKey: %@, host: %@", cacheKey, host);
+        cachedHostObject = [[HttpdnsHostObject alloc] init];
+    }
+
+    [cachedHostObject setCacheKey:cacheKey];
+    [cachedHostObject setClientIp:result.clientIp];
+
+    [cachedHostObject setHostName:host];
+    [cachedHostObject setIsLoadFromDB:NO];
+    [cachedHostObject setHasNoIpv4Record:hasNoIpv4Record];
+    [cachedHostObject setHasNoIpv6Record:hasNoIpv6Record];
+
+    if ([HttpdnsUtil isNotEmptyArray:v4IpObjects]) {
+        [cachedHostObject setV4Ips:v4IpObjects];
+        [cachedHostObject setV4TTL:result.getV4TTL];
+        [cachedHostObject setLastIPv4LookupTime:result.lastIPv4LookupTime];
+    }
+
+    if ([HttpdnsUtil isNotEmptyArray:v6IpObjects]) {
+        [cachedHostObject setV6Ips:v6IpObjects];
+        [cachedHostObject setV6TTL:result.getV6TTL];
+        [cachedHostObject setLastIPv6LookupTime:result.lastIPv6LookupTime];
+    }
+
+    if ([HttpdnsUtil isNotEmptyString:extra]) {
+        [cachedHostObject setExtra:extra];
+    }
+
+    HttpdnsLogDebug("Updated hostObject to cached, cacheKey: %@, host: %@", cacheKey, host);
+
+    // 由于从缓存中读取到的是拷贝出来的新对象，字段赋值不会影响缓存中的值对象，因此这里无论如何都要放回缓存
+    [_hostObjectInMemoryCache setHostObject:cachedHostObject forCacheKey:cacheKey];
+
+    [self persistToDB:cacheKey hostObject:cachedHostObject];
+
+    NSArray *ipv4StrArray = [cachedHostObject getV4IpStrings];
+    if ([HttpdnsUtil isNotEmptyArray:ipv4StrArray]) {
+        [self initiateQualityDetectionForIP:ipv4StrArray forHost:host cacheKey:cacheKey];
+    }
+
+    NSArray *ipv6StrArray = [cachedHostObject getV6IpStrings];
+    if ([HttpdnsUtil isNotEmptyArray:ipv6StrArray]) {
+        [self initiateQualityDetectionForIP:ipv6StrArray forHost:host cacheKey:cacheKey];
+    }
+    return cachedHostObject;
+}
+
+- (void)initiateQualityDetectionForIP:(NSArray *)ipArray forHost:(NSString *)host cacheKey:(NSString *)cacheKey {
+    HttpDnsService *service = self.ownerService ?: [HttpDnsService sharedInstance];
+    NSDictionary<NSString *, NSNumber *> *dataSource = [service getIPRankingDatasource];
+    if (!dataSource || ![dataSource objectForKey:host]) {
+        return;
+    }
+    NSNumber *port = [dataSource objectForKey:host];
+    for (NSString *ip in ipArray) {
+        [[HttpdnsIPQualityDetector sharedInstance] scheduleIPQualityDetection:cacheKey
+                                                                           ip:ip
+                                                                         port:port
+                                                                     callback:^(NSString * _Nonnull cacheKey, NSString * _Nonnull ip, NSInteger costTime) {
+            [self->_hostObjectInMemoryCache updateQualityForCacheKey:cacheKey forIp:ip withConnectedRT:costTime];
+        }];
+    }
+}
+
+- (BOOL)isHostsNumberLimitReached {
+    if ([_hostObjectInMemoryCache count] >= HTTPDNS_MAX_MANAGE_HOST_NUM) {
+        HttpdnsLogDebug("Can't handle more than %d hosts due to the software configuration.", HTTPDNS_MAX_MANAGE_HOST_NUM);
+        return YES;
+    }
+    return NO;
+}
+
+- (void)handleReachabilityNotification:(NSNotification *)notification {
+    [self networkChanged];
+}
+
+- (void)networkChanged {
+    HttpdnsNetworkStatus currentStatus = [[HttpdnsReachability sharedInstance] currentReachabilityStatus];
+    NSString *currentStatusString = [[HttpdnsReachability sharedInstance] currentReachabilityString];
+
+    // 重新检测协议栈代价小，所以只要网络切换就发起检<EFBFBD><EFBFBD>?
+    // 但考虑到网络切换后不稳定，还是延迟1秒才发起
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{
+        [[HttpdnsIpStackDetector sharedInstance] redetectIpStack];
+    });
+
+    NSTimeInterval currentTimestamp = [NSDate date].timeIntervalSince1970;
+    BOOL statusChanged = (_lastNetworkStatus != currentStatus);
+
+    // 仅在以下情况下响应网络变化去尝试更新缓存:
+    // - 距离上次处理事件至少过去了较长时间，<EFBFBD><EFBFBD>?
+    // - 网络状态发生变化且至少过去了较短时<EFBFBD><EFBFBD>?
+    NSTimeInterval elapsedTime = currentTimestamp - _lastUpdateTimestamp;
+    if (elapsedTime >= 5 || (statusChanged && elapsedTime >= 1)) {
+        HttpdnsLogDebug("Processing network change: oldStatus: %ld, newStatus: %ld(%@), elapsedTime=%.2f seconds",
+                        _lastNetworkStatus, currentStatus, currentStatusString, elapsedTime);
+
+        // 更新调度
+        // 网络在切换过程中可能不稳定，所以发送请求前等待2<EFBFBD><EFBFBD>?
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{
+            HttpdnsScheduleCenter *scheduleCenter = self.ownerService.scheduleCenter;
+            [scheduleCenter asyncUpdateRegionScheduleConfig];
+        });
+
+        // 复杂逻辑（仅注释关键点，避免冗余）：
+        // 网络切换后只预解析“cacheKey 等于 hostName”的条目<EFBFBD><EFBFBD>?
+        // 这些条目代表标准域名缓存；SDNS 等使用自定义 cacheKey 的记录不在此批次处理<EFBFBD><EFBFBD>?
+        NSArray *allKeys = [_hostObjectInMemoryCache allCacheKeys];
+        NSMutableArray<NSString *> *hostArray = [NSMutableArray array];
+        for (NSString *key in allKeys) {
+            HttpdnsHostObject *obj = [self->_hostObjectInMemoryCache getHostObjectByCacheKey:key];
+            if (!obj) {
+                continue;
+            }
+            NSString *cacheKey = [obj getCacheKey];
+            NSString *hostName = [obj getHostName];
+            if (cacheKey && hostName && [cacheKey isEqualToString:hostName]) {
+                [hostArray addObject:hostName];
+            }
+        }
+
+        // 预解<EFBFBD><EFBFBD>?
+        // 网络在切换过程中可能不稳定，所以在清理缓存和发送请求前等待3<EFBFBD><EFBFBD>?
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{
+            // 仅清理“hostName 键”的缓存，保<EFBFBD><EFBFBD>?SDNS 等自定义 cacheKey 的记<EFBFBD><EFBFBD>?
+            for (NSString *host in hostArray) {
+                [self->_hostObjectInMemoryCache removeHostObjectByCacheKey:host];
+            }
+
+            if (self.atomicPreResolveAfterNetworkChanged && hostArray.count > 0) {
+                HttpdnsLogDebug("Network changed, pre resolve for host-key entries: %@", hostArray);
+                [self preResolveHosts:hostArray queryType:HttpdnsQueryIPTypeAuto];
+            }
+        });
+
+        // 更新时间戳和状<EFBFBD><EFBFBD>?
+        _lastNetworkStatus = currentStatus;
+        _lastUpdateTimestamp = currentTimestamp;
+    } else {
+        HttpdnsLogDebug("Ignoring network change event: oldStatus: %ld, newStatus: %ld(%@), elapsedTime=%.2f seconds",
+                        _lastNetworkStatus, currentStatus, currentStatusString, elapsedTime);
+    }
+}
+
+#pragma mark -
+#pragma mark - disable status Setter and Getter Method
+
+- (dispatch_queue_t)cacheQueue {
+    if (!_cacheQueue) {
+        _cacheQueue = dispatch_queue_create("com.Trust.sdk.httpdns.cacheDisableStatusQueue", DISPATCH_QUEUE_SERIAL);
+    }
+    return _cacheQueue;
+}
+
+#pragma mark -
+#pragma mark - Flag for Disable and Sniffer Method
+
+- (void)loadCacheFromDbToMemory {
+    NSArray<HttpdnsHostRecord *> *hostRecords = [self->_httpdnsDB getAllRecords];
+
+    if ([HttpdnsUtil isEmptyArray:hostRecords]) {
+        return;
+    }
+
+    for (HttpdnsHostRecord *hostRecord in hostRecords) {
+        NSString *hostName = hostRecord.hostName;
+        NSString *cacheKey = hostRecord.cacheKey;
+
+        HttpdnsHostObject *hostObject = [HttpdnsHostObject fromDBRecord:hostRecord];
+
+        // 从持久层加载到内存的缓存，需要做个标记，App启动后从缓存使用结果时，根据标记做特殊处<EFBFBD><EFBFBD>?
+        [hostObject setIsLoadFromDB:YES];
+
+        [self->_hostObjectInMemoryCache setHostObject:hostObject forCacheKey:cacheKey];
+
+        NSArray *v4IpStrArr = [hostObject getV4IpStrings];
+        if ([HttpdnsUtil isNotEmptyArray:v4IpStrArr]) {
+            [self initiateQualityDetectionForIP:v4IpStrArr forHost:hostName cacheKey:cacheKey];
+        }
+        NSArray *v6IpStrArr = [hostObject getV6IpStrings];
+        if ([HttpdnsUtil isNotEmptyArray:v6IpStrArr]) {
+            [self initiateQualityDetectionForIP:v6IpStrArr forHost:hostName cacheKey:cacheKey];
+        }
+    }
+}
+
+- (void)cleanMemoryAndPersistentCacheOfHostArray:(NSArray<NSString *> *)hostArray {
+    for (NSString *host in hostArray) {
+        if ([HttpdnsUtil isNotEmptyString:host]) {
+            [_hostObjectInMemoryCache removeHostObjectByCacheKey:host];
+        }
+    }
+
+    // 清空数据库数<EFBFBD><EFBFBD>?
+    dispatch_async(_persistentCacheConcurrentQueue, ^{
+        [self->_httpdnsDB deleteByHostNameArr:hostArray];
+    });
+}
+
+- (void)cleanMemoryAndPersistentCacheOfAllHosts {
+    [_hostObjectInMemoryCache removeAllHostObjects];
+
+    // 清空数据库数<EFBFBD><EFBFBD>?
+    dispatch_async(_persistentCacheConcurrentQueue, ^{
+        [self->_httpdnsDB deleteAll];
+    });
+}
+
+- (void)persistToDB:(NSString *)cacheKey hostObject:(HttpdnsHostObject *)hostObject {
+    if (!_persistentCacheIpEnabled) {
+        return;
+    }
+    dispatch_async(_persistentCacheConcurrentQueue, ^{
+        HttpdnsHostRecord *hostRecord = [hostObject toDBRecord];
+        [self->_httpdnsDB createOrUpdate:hostRecord];
+    });
+}
+
+#pragma mark -
+#pragma mark - 以下函数仅用于测试目<EFBFBD><EFBFBD>?
+
+- (NSString *)showMemoryCache {
+    NSString *cacheDes;
+    cacheDes = [NSString stringWithFormat:@"%@", _hostObjectInMemoryCache];
+    return cacheDes;
+}
+
+- (void)cleanAllHostMemoryCache {
+    [_hostObjectInMemoryCache removeAllHostObjects];
+}
+
+- (void)syncLoadCacheFromDbToMemory {
+    [self loadCacheFromDbToMemory];
+}
+
+- (void)dealloc {
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+@end