HarmonyOS 对于json字符串转具体类对象的方案(反序列化操作)

export class Objects { 
  /** 
 
   把data中的属性赋值给target对象中的数据 
   @param target 
   @param data 
   */ 
  static fillProperties<T extends  PropertyFiller>(target: T, data: Record<string, Object>): void { 
 
    if (target === undefined || target === null || data === undefined || data === null) { 
      // 如果target或者data为空，则不赋值 
      return 
    } 
    if (typeof target !== 'object') { 
      // 如果target不是对象类型，不允许赋值 
      return 
    } 
    Object.keys(data).forEach((key: string): void => { 
      let value: Object = data[key] 
      if (typeof value === 'string') { 
        Reflect.set(target, key, value as string) 
      } else if (typeof value === 'boolean') { 
        Reflect.set(target, key, value as boolean) 
      } else if (typeof value === 'number') { 
        Reflect.set(target, key, value as number) 
      } else if (typeof value === 'object') { 
        if (Array.isArray(value)) { 
          // 如果value是数组，则调用填充数组属性的方法 
          target.fillArrayProperties(key, value as Object[]) 
        } else { 
          // 如果value是object，则调用填充object属性的方法 
          target.fillObjectProperties(key, value as Record<string, Object>) 
        } 
      } else { 
        console.log("Test not support [" + key + "] type: " + typeof value) 
      } 
    }) 
  } }
export interface PropertyFiller { 
 
  /** 
 
   填充object类型的属性 
   @param key 属性名称 
   @param value 属性值 
   */ 
 
  fillObjectProperties(key: string, value: Record<string, Object>): void 
 
  /** 
 
   填充数组类型的属性 
   @param key 属性名 
   @param value 属性值 
   */ 
 
  fillArrayProperties(key: string, value: Object[]): void } 
 
// 属性填充器接口抽象实现类，定义入参构造函数并调用初始化属性方法；接口空实现，子类按需实现 
 
export abstract class PropertyFillerImpl implements PropertyFiller { 
 
  /** 
 
   构造函数 
   @param value json对象型入参 
   */ 
 
  constructor(value?: Record<string, Object>) { 
 
    if (value !== undefined && value !== null) { 
      // 如果入参有值，则调用工具类填充属性值 
      Objects.fillProperties(this, value) 
    } 
  } 
 
  fillObjectProperties(key: string, value: Record<string, Object>): void { 
 
  } 
 
  fillArrayProperties(key: string, value: Object[]): void { 
 
  } 
 
} 
 
class TestAdModel extends PropertyFillerImpl{ 
 
  name?:string 
 
  public test():string{ 
 
    return "string" 
  } } 
 
export class Response extends PropertyFillerImpl{ 
 
  code?:string 
 
  message?:string 
 
  data?:TestAdModel 
 
  test():string{ 
 
    return "string" 
  } 
  fillObjectProperties(key: string, value: Record<string, Object>){ 
 
    if (key === "data") { 
      this.data = new TestAdModel(value) as TestAdModel 
    } 
  } 
 
} 
 
let model :TestAdModel = new TestAdModel(); 
 
model.name = "test" 
 
let response:Response = new Response() 
 
response.code = "0" 
 
response.message = "success" 
 
response.data = model 
 
let responseStr:string = JSON.stringify(response); 
 
let response2:Response = new Response(JSON.parse(responseStr)) 
 
if(response2.data !== undefined) { 
 
  console.log(response2.data.test()); 
 
  console.log(response2.data.name); } 
 
console.log(response2.test());