HarmonyOS 鸿蒙Next中自用的 preferences 范型工具类

import preferences from '@ohos.data.preferences';
import common from '@ohos.app.ability.common';
import { Log } from '../utils';

const log = Log.scope("PreferencesUtil :")

class PreferencesUtil<PreferencesNameSpace, NameSpace = keyof PreferencesNameSpace, Value = PreferencesNameSpace[keyof PreferencesNameSpace]> {
  preMap: Map<NameSpace, preferences.Preferences> = new Map()

  async createPreferences(context: common.BaseContext, namespace: NameSpace & string) {
    const preference = this.preMap.has(namespace)
    if (!preference) {
      this.loadPreferences(context, namespace)
    }
  }

  private async loadPreferences(context: common.BaseContext, namespace: NameSpace & string) {
    try {
      const preference = await preferences.getPreferences(context, namespace)
      this.preMap.set(namespace, preference)
      log.info("【loadPreferences】 ok", namespace)
      return preference
    } catch (err) {
      log.error("【loadPreferences】 fail", namespace, err)
    }
  }

  async putV(namespace: NameSpace, key: keyof Value & string, value: preferences.ValueType) {
    try {
      const preference = this.preMap.get(namespace)
      if (!preference) {
        return
      }
      await preference.put(key, value)
      log.info("【putV】 ok", namespace)
      await preference.flush()
      return true
    } catch (err) {
      log.error("【putV】 fail", namespace, err)
    }
    return false
  }

  async getV(namespace: NameSpace, key: keyof Value & string, defValue: preferences.ValueType) {
    try {
      const preference = this.preMap.get(namespace)
      if (!preference) {
        return
      }
      const value = await preference.get(key, defValue)
      log.info("【getV】 ok", namespace)
      return value
    } catch (err) {
      log.info("【getV】 fail", namespace,)
    }
  }

  async deleteV(namespace: NameSpace, key: keyof Value & string) {
    try {
      const preference = this.preMap.get(namespace)
      if (!preference) {
        return
      }
      await preference.delete(key)
      await preference.flush()
      log.info("【deleteV】 ok", namespace)
    } catch (err) {
      log.info("【deleteV】 fail", namespace,)
    }
  }

  async clear(namespace: NameSpace) {
    try {
      const preference = this.preMap.get(namespace)
      if (!preference) {
        return
      }
      await preference.clear()
      await preference.flush()
      log.info("【clear】 ok", namespace)
    } catch (err) {
      log.info("【clear】 fail", namespace,)
    }
  }
}

// 系统本地存储
export type NameSpaceStruct = {
  //如果 |string 又没提示了
  "sys": Record<"af" | "b", preferences.ValueType>,
  "page1": Record<string, preferences.ValueType>
}

export default new PreferencesUtil<NameSpaceStruct>()

更多关于HarmonyOS 鸿蒙Next中自用的 preferences 范型工具类的实战教程也可以访问 https://www.itying.com/category-93-b0.html

yibo5220 1楼

更多关于HarmonyOS 鸿蒙Next中自用的 preferences 范型工具类的实战系列教程也可以访问 https://www.itying.com/category-93-b0.html

在HarmonyOS的鸿蒙Next中，preferences 是一种轻量级的数据存储方式，用于存储用户的偏好设置或简单的键值对数据。为了增强类型安全性和代码复用性，可以使用范型工具类来封装 preferences 的操作。以下是一个简单的范型工具类示例：

import ohos.data.preferences.Preferences;

public class PreferencesHelper<T> {
    private final Preferences preferences;

    public PreferencesHelper(Preferences preferences) {
        this.preferences = preferences;
    }

    public void put(String key, T value) {
        if (value instanceof String) {
            preferences.putString(key, (String) value);
        } else if (value instanceof Integer) {
            preferences.putInt(key, (Integer) value);
        } else if (value instanceof Boolean) {
            preferences.putBoolean(key, (Boolean) value);
        } else if (value instanceof Long) {
            preferences.putLong(key, (Long) value);
        } else if (value instanceof Float) {
            preferences.putFloat(key, (Float) value);
        }
        preferences.flush();
    }

    public T get(String key, T defaultValue) {
        if (defaultValue instanceof String) {
            return (T) preferences.getString(key, (String) defaultValue);
        } else if (defaultValue instanceof Integer) {
            return (T) (Integer) preferences.getInt(key, (Integer) defaultValue);
        } else if (defaultValue instanceof Boolean) {
            return (T) (Boolean) preferences.getBoolean(key, (Boolean) defaultValue);
        } else if (defaultValue instanceof Long) {
            return (T) (Long) preferences.getLong(key, (Long) defaultValue);
        } else if (defaultValue instanceof Float) {
            return (T) (Float) preferences.getFloat(key, (Float) defaultValue);
        }
        return defaultValue;
    }
}

这个工具类通过范型支持多种数据类型，简化了 preferences 的使用，并提高了代码的可读性和安全性。