앱 로컬 구성 지속성 솔루션

개요

앱 개발 프로세스 중에 간단한 구성 항목에 대한 많은 지속성 요구 사항이 발생합니다. 예를 들어, 앱이 마지막으로 실행된 시간, 앱에 마지막으로 로그인한 사용자 ID, 사용자가 처음으로 기능을 사용하기 위한 판단 조건입니다. 그리고 비즈니스가 확장됨에 따라 단편화된 구성은 계속해서 증가할 것입니다.

사용자 기본값

Apple은 개별 구성을 저장하는 데 도움이 되는 UserDefault 프레임워크를 제공하며 UserDefaults는 plist 파일 형식으로 샌드박스 환경에 저장됩니다. NoSql 데이터베이스를 도입하지 않고 가장 권장되는 솔루션입니다.

지침

읽기 속도를 향상시키기 위해 앱은 시작 시 UserDefaults Standard에 해당하는 plist를 메모리에 로드합니다.파일이 너무 크면 시작 시 앱의 로드 시간이 증가하고 메모리 소비가 일정 수준으로 증가합니다. 정도.

따라서 Standard에서는 사용자의 가장 최근 로그인 ID, 앱의 원격 구성 캐시 버전과 같이 앱 시작 단계에서 즉시 가져와야 하는 정보를 저장해야 합니다.

테이블을 분할하여 표준 데이터의 양을 줄일 수 있습니다. UserDefaults의 suiteName 모드를 사용하여 구성 항목이 자체 plist 파일에 저장되고 이러한 독립적인 plist가 시작 시 자동으로 로드되지 않도록 다른 구성 테이블을 만듭니다.

구성 관리에 대한 자주 묻는 질문

1. 하드 코딩된 문자열 키를 사용하여 구성을 UserDefaults에 저장하고 키 문자열을 복사하고 붙여넣어 데이터에 액세스합니다.

2. UserDefaults의 분산된 사용에는 중앙 집중식 관리 솔루션이 없습니다. 예를 들어 "알림 기능 활성화"라는 설정을 저장해야 하는 경우 키는 대개 비즈니스 관련 코드에서 직접 관리됩니다.

계획 1.0

사용자 기본값 관리

UserDefault 관리 클래스를 생성합니다. 주요 목적은 UserDefault 프레임워크를 닫고 사용 전략을 통합하는 것입니다.

public class UserDefaultsManager {
    public static let shared = UserDefaultsManager()
    private init() {}
    public var suiteName:String? {
        didSet {
            /**
             根据传入的 suiteName的不同会产生四种情况：
             传入 nil：跟使用UserDefaults.standard效果相同；
             传入 bundle id：无效，返回 nil；
             传入 App Groups 配置中 Group ID：会操作 APP 的共享目录中创建的以Group ID命名的 plist 文件，方便宿主应用与扩展应用之间共享数据；
             传入其他值：操作的是沙箱中 Library/Preferences 目录下以 suiteName 命名的  plist 文件。
             */
            userDefault = UserDefaults(suiteName: suiteName) ?? UserDefaults.standard
        }
    }
    public var userDefault = UserDefaults.standard
}

复制代码

상수 테이블 생성

1. 구성 항목 키의 중앙 집중식 등록 및 유지 관리

struct UserDefaultsKey {
    static let appLanguageCode              = "appLanguageCode"
    static let lastLaunchSaleDate           = "resetLastLaunchSaleDate"
    static let lastSaleDate                 = "lastSaleDate"
    static let lastSaveRateDate             = "lastSaveRateDate"
    static let lastVibrateTime              = "lastVibrateTime"
    static let exportedImageSaveCount       = "exportedImageSaveCount"
  
    static let onceFirstLaunchDate          = "onceFirstLaunchDate"
    static let onceServerUserIdStr          = "onceServerUserIdStr"
    static let onceDidClickCanvasButton     = "onceDidClickCanvasButton"
    static let onceDidClickCanvasTips       = "onceDidClickCanvasTips"
    static let onceDidClickEditBarGuide     = "onceDidClickEditBarGuide"
    static let onceDidClickEditFreestyleGuide   = "onceDidClickEditFreestyleGuide"
    static let onceDidClickManualCutoutGuide    = "onceDidClickManualCutoutGuide"
    static let onceDidClickBackgroundBlurGuide  = "onceDidClickBackgroundBlurGuide"
    static let onceDidTapCustomStickerBubble    = "onceDidTapCustomStickerBubble"
    static let onceDidRequestHomeTemplatesFromAPI = "onceDidRequestHomeTemplatesFromAPI"
  
  	static let firSaveExportTemplateKey     = "firSaveExportTemplateKey"
    static let firSaveTemplateDateKey       = "firSaveTemplateDateKey"
    static let firShareExportTemplateKey    = "firShareExportTemplateKey"
    static let firShareTemplateDateKey      = "firShareTemplateDateKey"
}
复制代码

2. CURD API 제공

private let appConfigUserDefaults = UserDefaultsManager(suiteName: "com.pe.config").userDefaults

var exportedImageSaveCount: Int { 
  return appConfigUserDefaults.integer(forKey: key) 
}

func increaseExportedImageSaveCount() {
		let key = UserDefaultsKey.exportedImageSaveCount
		var count = appConfigUserDefaults.integer(forKey: key)
		count += 1
		appConfigUserDefaults.setValue(count, forKey: key)
}
复制代码

UserDefaults 데이터 소스를 캡슐화했으며 String Key 등록도 상수 파일로 통합되었습니다. 검색하거나 수정하려는 경우 구성 테이블에서 문자열 키를 쉽게 찾을 수 있습니다.

비즈니스가 확장됨에 따라 구성 항목이 점점 더 많아지고 비즈니스 기능 분류에 따라 여러 하위 테이블을 재정렬해야 합니다.

그런 다음 몇 가지 문제를 찾을 수 있습니다.

1. String Key的注册虽然不麻烦，但Key中无法体现出Key归属与哪个UserDefaults。

2. CURD API的数量会膨胀的更快，需要更多的维护成本。那么能不能将配置的管理更加面向对象，实现类似ORM的方式来管理呢？

方案2.0

根据上述的问题，来演化下方案2.0，我们来创建一个协议，用来规范UserDefaults的使用类。

它将包含CURD API的默认实现，初始化关联UserDefaults，自动生成String Key。

/// UserDefaults存储协议，建议用String类型的枚举去实现该协议
public protocol UserDefaultPreference {

    var userDefaults: UserDefaults { get }
    var key: String { get }

    var bool: Bool { get }
    var int: Int { get }
    var float: Float { get }
    var double: Double { get }

    var string: String? { get }
    var stringValue: String { get }

    var dictionary: [String: Any]? { get }
    var dictionaryValue: [String: Any] { get }

    var array: [Any]? { get }
    var arrayValue: [Any] { get }

    var stringArray: [String]? { get }
    var stringArrayValue: [String] { get }

    var data: Data? { get }
    var dataValue: Data { get }

    var object: Any? { get }
    var url: URL? { get }

    func codableObject<T: Decodable>(_ as:T.Type) -> T?

    func save<T: Encodable>(codableObject: T) -> Bool

    func save(string: String)
    func save(object: Any?)
    func save(int: Int)
    func save(float: Float)
    func save(double: Double)
    func save(bool: Bool)
    func save(url: URL?)
    func remove()
}
复制代码

定义完协议后，我们再添加一些默认实现，降低使用成本。

// 生成默认的String Key
public extension UserDefaultPreference where Self: RawRepresentable, Self.RawValue == String {
    var key: String {  return "\(type(of: self)).\(rawValue)" }
}

public extension UserDefaultPreference {
		// 默认使用 standard UserDefaults，可以在实现类中配置
    var userDefaults: UserDefaults { return UserDefaultsManager.shared.userDefaults }

    func codableObject<T: Decodable>(_ as:T.Type) -> T? {
        return UserDefaultsManager.codableObject(`as`, key: key, userDefaults: userDefaults)
    }

    @discardableResult
    func save<T: Encodable>(codableObject: T) -> Bool {
        return UserDefaultsManager.save(codableObject: codableObject, key: key, userDefaults: userDefaults)
    }

    var object: Any? { return userDefaults.object(forKey: key) }

    func hasKey() -> Bool { return userDefaults.object(forKey: key) != nil }

    var url: URL? { return userDefaults.url(forKey: key) }

    var string: String? { return userDefaults.string(forKey: key) }
    var stringValue: String { return string ?? "" }

    var dictionary: [String: Any]? { return userDefaults.dictionary(forKey: key) }
    var dictionaryValue: [String: Any] { return dictionary ?? [String: Any]() }

    var array: [Any]? { return userDefaults.array(forKey: key) }
    var arrayValue: [Any] { return array ?? [Any]() }

    var stringArray: [String]? { return userDefaults.stringArray(forKey: key) }
    var stringArrayValue: [String] { return stringArray ?? [String]() }

    var data: Data? { return userDefaults.data(forKey: key) }
    var dataValue: Data { return userDefaults.data(forKey: key) ?? Data() }

    var bool: Bool { return userDefaults.bool(forKey: key) }
    var boolValue: Bool? {
        guard hasKey() else { return nil }
        return bool
    }

    var int: Int { return userDefaults.integer(forKey: key) }
    var intValue: Int? {
        guard hasKey() else { return nil }
        return int
    }

    var float: Float { return userDefaults.float(forKey: key) }
    var floatValue: Float? {
        guard hasKey() else { return nil }
        return float
    }

    var double: Double { return userDefaults.double(forKey: key) }
    var doubleValue: Double? {
        guard hasKey() else { return nil }
        return double
    }

    func save(object: Any?) { userDefaults.set(object, forKey: key) }
    func save(string: String) { userDefaults.set(string, forKey: key) }
    func save(int: Int) { userDefaults.set(int, forKey: key) }
    func save(float: Float) { userDefaults.set(float, forKey: key) }
    func save(double: Double) { userDefaults.set(double, forKey: key) }
    func save(bool: Bool) { userDefaults.set(bool, forKey: key) }
    func save(url: URL?) { userDefaults.set(url, forKey: key) }

    func remove() { userDefaults.removeObject(forKey: key) }
}
复制代码

OK，我们来看下使用的案例

// MARK: - Launch
enum LaunchEventKey: String {
    case didShowLaunchGuideOnThisLaunch
    case launchGuideIsAlreadyShow
}
extension LaunchEventKey: UserDefaultPreference { }

func checkIfNeedLaunchGuide() -> Bool {
  return !LaunchEventKey.launchGuideIsAlreadyShow.bool  
}
func launchContentView() {
  LaunchEventKey.launchGuideIsAlreadyShow.save(bool: true)  
}

// MARK: - Language
enum LanguageEventKey: String {
    case appLanguageCode
}
extension LanguageEventKey: UserDefaultPreference { }

static var appLanguageCode: String {
  get {
    let code = LanguageEventKey.appLanguageCode.string ?? ""
    return code
  }
  set {
    LanguageEventKey.appLanguageCode.save(codableObject: newValue)
  }
}

// MARK: - Purchase
enum PurchaseStatusKey: String {
    case iapSubscribeExpireDate
}
extension PurchaseStatusKey: UserDefaultPreference { }

func handle() {
  let expirationDate: Date = Entitlement.expirationDate
  PurchaseStatusKey.iapSubscribeExpireDate.save(object: expirationDate)
}

func getValues() {
  let subscribeExpireDate = PurchaseStatusKey.iapSubscribeExpireDate.object as? Date
}

// MARK: - GlobalConfig
enum AppConfig: String {
    case globalConfig
}

private let appConfigUserDefaults = UserDefaultsManager(suiteName: "com.pe.AppConfig").userDefaults

extension AppConfig: UserDefaultPreference {
    var userDefaults: UserDefaults { return appConfigUserDefaults }
}

// 自定义类型
public class GlobalConfig: Codable {
    /// 配置版本号
    let configVersion: Int
    /// 用户初始试用次数
    let userInitialTrialCount: Int
    /// 生成时间 如：2022-09-19T02:58:31Z
    let createDate: String

    enum CodingKeys: String, CodingKey {
        case configVersion = "version"
        case userInitialTrialCount = "user_initial_trial_count"
        case createDate = "create_date"
    }
	  ...
}

lazy var globalConfig: GlobalConfig = {
  guard let config = AppConfig.globalConfig.codableObject(GlobalConfig.self) else {
    return GlobalConfig()
  }
  return config
}() {
  didSet { AppConfig.globalConfig.save(codableObject: globalConfig) }
}
复制代码

从上述案例可以看出，在配置项的注册和维护成本相对方案1.0有了大幅度的降低，对UserDefaults的使用进行了规范性的约束，提供了更方便的CURD API，使用方式也更加符合面向对象的习惯。

同时为了满足复杂结构体的存储需求，我们可以扩展实现Codable对象的存取逻辑。

总结

本方案的目的是解决乱象丛生的UserDefaults的使用情况，分析后向两个方向进行了优化：

1. 提供中心化的配置方式，关联UserDefaults、维护String Key。
2. 提供类ORM的管理方式，减少业务的接入成本。

针对更复杂的、类缓存集合的，或者有查询需求的配置项管理，请尽快用NoSQL替换，避免数据量上升带来的效率下降。