嘿，针对你需要在客户端控制AlamofireImage缓存3天过期的需求，我来给你几个可行的方案——毕竟没服务器权限的话，就得自己在app里搞定缓存的生命周期管理啦。

首先得明确：AlamofireImage默认依赖系统的URLCache来做磁盘缓存，而URLCache默认是遵循服务器返回的HTTP缓存头（比如Cache-Control）。既然你没法改服务器配置，那我们就得自己加一层逻辑来控制缓存过期。

方案1：下载前检查缓存是否过期，按需选择缓存策略 #

这个方法的核心是在发起图片请求前，先检查本地缓存的创建时间，如果超过3天就强制重新下载，否则优先用缓存。

步骤1：写一个缓存过期检查工具函数 #

func isImageCacheExpired(for url: URL, expirationDays: TimeInterval = 3) -> Bool {
    let urlCache = URLCache.shared
    guard let cachedResponse = urlCache.cachedResponse(for: URLRequest(url: url)) else {
        return true // 没有缓存，直接视为过期
    }
    
    // 获取缓存响应的时间（服务器返回的Date头，或者缓存文件的创建时间）
    let cacheDate = cachedResponse.response.date ?? {
        // 如果服务器没返回Date头，就取缓存文件的创建时间
        guard let cachePath = urlCache.diskCachePath?.appending("/\(url.hashValue)") else {
            return Date.distantPast
        }
        return (try? FileManager.default.attributesOfItem(atPath: cachePath)[.creationDateKey]) as? Date ?? Date.distantPast
    }()
    
    let expirationDate = cacheDate.addingTimeInterval(expirationDays * 24 * 60 * 60)
    return Date() > expirationDate
}

步骤2：自定义请求调用af_setImage #

不再直接用af_setImage(withURL:)，而是先构造带缓存策略的请求：

let imageURL = URL(string: "https://your-image-url.com/image.jpg")!
var imageRequest = URLRequest(url: imageURL)

if isImageCacheExpired(for: imageURL) {
    // 缓存过期，强制重新下载
    imageRequest.cachePolicy = .reloadIgnoringLocalCacheData
} else {
    // 缓存有效，优先用缓存，缓存失效再下载
    imageRequest.cachePolicy = .returnCacheDataElseLoad
}

// 发起请求
yourImageView.af_setImage(withURLRequest: imageRequest) { response in
    // 可选：处理下载完成后的回调，比如更新UI或记录日志
    if response.error != nil {
        print("图片下载失败：\(response.error!)")
    }
}

方案2：定期清理过期缓存 #

上面的方案能控制是否使用过期缓存，但过期的缓存文件还会留在磁盘里占用空间，所以需要定期清理这些过期文件。

写一个清理过期缓存的函数 #

func cleanExpiredImageCache(expirationDays: TimeInterval = 3) {
    let urlCache = URLCache.shared
    guard let diskCacheDir = urlCache.diskCachePath else {
        print("无法获取磁盘缓存目录")
        return
    }
    
    do {
        let cacheFiles = try FileManager.default.contentsOfDirectory(atPath: diskCacheDir)
        let expirationDate = Date().addingTimeInterval(-expirationDays * 24 * 60 * 60)
        
        for fileName in cacheFiles {
            let filePath = diskCacheDir.appending("/\(fileName)")
            let fileAttributes = try FileManager.default.attributesOfItem(atPath: filePath)
            
            if let creationDate = fileAttributes[.creationDateKey] as? Date, creationDate < expirationDate {
                try FileManager.default.removeItem(atPath: filePath)
                print("清理过期缓存文件：\(fileName)")
            }
        }
    } catch {
        print("清理过期缓存失败：\(error.localizedDescription)")
    }
}

调用时机 #

你可以在合适的时机触发清理：

• App启动时（比如AppDelegate的application(_:didFinishLaunchingWithOptions:)方法里）
• App进入后台时（AppDelegate的applicationDidEnterBackground(_:)）
• 定期用后台任务触发（需要配置后台模式，适合缓存量大的情况）

方案3：自定义URLCache子类（更彻底的控制） #

如果上面的方案不够灵活，你可以自定义URLCache的子类，重写缓存存储和读取的逻辑，从底层控制缓存过期。不过这个方案复杂度稍高，适合需要更精细控制缓存的场景。

class ExpiringURLCache: URLCache {
    let expirationDays: TimeInterval
    
    init(memoryCapacity: Int, diskCapacity: Int, diskPath: String?, expirationDays: TimeInterval = 3) {
        self.expirationDays = expirationDays
        super.init(memoryCapacity: memoryCapacity, diskCapacity: diskCapacity, diskPath: diskPath)
    }
    
    override func storeCachedResponse(_ cachedResponse: CachedURLResponse, for request: URLRequest) {
        // 存储时可以额外记录缓存时间，或者直接用响应的Date头
        super.storeCachedResponse(cachedResponse, for: request)
    }
    
    override func cachedResponse(for request: URLRequest) -> CachedURLResponse? {
        guard let cachedResponse = super.cachedResponse(for: request) else {
            return nil
        }
        
        let cacheDate = cachedResponse.response.date ?? Date.distantPast
        let expirationDate = cacheDate.addingTimeInterval(expirationDays * 24 * 60 * 60)
        
        if Date() > expirationDate {
            // 缓存过期，移除并返回nil
            removeCachedResponse(for: request)
            return nil
        }
        
        return cachedResponse
    }
}

然后在App启动时替换默认的URLCache：

// 在AppDelegate的didFinishLaunchingWithOptions里
let customCache = ExpiringURLCache(memoryCapacity: 10 * 1024 * 1024, // 10MB内存缓存
                                   diskCapacity: 50 * 1024 * 1024,  // 50MB磁盘缓存
                                   diskPath: "com.alamofire.imagedownloader",
                                   expirationDays: 3)
URLCache.shared = customCache

这样之后，所有通过AlamofireImage发起的请求都会自动遵循3天的缓存过期规则，不用每次请求都手动处理。

总结一下，方案1+方案2是最容易上手的组合，既能控制是否使用过期缓存，又能定期清理磁盘垃圾；方案3则是一劳永逸的底层解决方案，适合长期维护的项目。

内容的提问来源于stack exchange，提问作者ozd