Swift/Obj-C中如何用泛型类与函数实现对象转JSON

嘿，我来帮你搞定这个泛型转JSON的需求！咱们分Swift和Objective-C两种情况来拆解，核心思路是用协议约束可转换的类型，让泛型知道该如何处理传入的对象，一步步来～

Swift 实现方案 #

1. 定义JSON转换协议 #

首先得给可转换的类型定个规矩：所有要转JSON的类都得实现一个转字典的方法。我们定义一个JSONConvertible协议：

protocol JSONConvertible {
    func toJSON() -> [String: Any?]
}

2. 让Type1、Type2遵守协议 #

给你的两个类扩展实现协议方法，各自负责把自己的成员变量转成对应键值对：

class Type1 { 
    var member1: String? 
    var member2: String? 
    init(member1: String,member2: String) { 
        self.member1 = member1 
        self.member2 = member2 
    } 
}

extension Type1: JSONConvertible {
    func toJSON() -> [String: Any?] {
        return [
            "member1": member1,
            "member2": member2
        ]
    }
}

class Type2 { 
    var member3: String? 
    var member4: String? 
    init(member3: String,member4: String) { 
        self.member3 = member3 
        self.member4 = member4 
    } 
}

extension Type2: JSONConvertible {
    func toJSON() -> [String: Any?] {
        return [
            "member3": member3,
            "member4": member4
        ]
    }
}

3. 泛型函数/类实现转换 #

现在就可以写泛型代码了，只要是遵守JSONConvertible的类型，都能被处理：

泛型函数

func convertToJSON<T: JSONConvertible>(_ object: T) -> [String: Any?] {
    return object.toJSON()
}

泛型工具类（如果需要类形式的话）

class JSONConverter<T: JSONConvertible> {
    func convert(_ object: T) -> [String: Any?] {
        return object.toJSON()
    }
}

测试验证 #

let type1Obj = Type1(member1: "someValue1", member2: "someValue2")
print(convertToJSON(type1Obj)) // 输出 ["member1": "someValue1", "member2": "someValue2"]

let type2Obj = Type2(member3: "someValue3", member4: "someValue4")
let converter = JSONConverter<Type2>()
print(converter.convert(type2Obj)) // 输出 ["member3": "someValue3", "member4": "someValue4"]

如果需要转成JSON字符串，还可以给协议加个扩展：

extension JSONConvertible {
    func toJSONString() -> String? {
        guard let data = try? JSONSerialization.data(withJSONObject: toJSON(), options: .prettyPrinted) else {
            return nil
        }
        return String(data: data, encoding: .utf8)
    }
}

// 调用示例
print(type1Obj.toJSONString() ?? "")

Objective-C 实现方案 #

OC的泛型主要是编译期检查，我们同样用协议来约束可转换类型，步骤类似：

1. 定义JSON转换协议 #

@protocol JSONConvertible <NSObject>
- (NSDictionary *)toJSON;
@end

2. 修改Type1、Type2并遵守协议 #

注意OC里类要继承NSObject，然后实现协议方法：

@interface Type1 : NSObject <JSONConvertible>
@property (nonatomic, copy) NSString *member1;
@property (nonatomic, copy) NSString *member2;
- (instancetype)initWithMember1:(NSString *)member1 member2:(NSString *)member2;
@end

@implementation Type1
- (instancetype)initWithMember1:(NSString *)member1 member2:(NSString *)member2 {
    self = [super init];
    if (self) {
        _member1 = member1;
        _member2 = member2;
    }
    return self;
}

#pragma mark - JSONConvertible
- (NSDictionary *)toJSON {
    // 用[NSNull null]处理nil值，避免JSON序列化失败
    return @{@"member1": _member1 ?: [NSNull null],
             @"member2": _member2 ?: [NSNull null]};
}
@end

@interface Type2 : NSObject <JSONConvertible>
@property (nonatomic, copy) NSString *member3;
@property (nonatomic, copy) NSString *member4;
- (instancetype)initWithMember3:(NSString *)member3 member4:(NSString *)member4;
@end

@implementation Type2
- (instancetype)initWithMember3:(NSString *)member3 member4:(NSString *)member4 {
    self = [super init];
    if (self) {
        _member3 = member3;
        _member4 = member4;
    }
    return self;
}

#pragma mark - JSONConvertible
- (NSDictionary *)toJSON {
    return @{@"member3": _member3 ?: [NSNull null],
             @"member4": _member4 ?: [NSNull null]};
}
@end

3. 泛型函数/类实现 #

OC的泛型函数和类写法如下，泛型约束为JSONConvertible：

泛型函数

NSDictionary *convertToJSON(id<JSONConvertible> object) {
    return [object toJSON];
}

泛型工具类

@interface JSONConverter<T: id<JSONConvertible>> : NSObject
- (NSDictionary *)convert:(T)object;
@end

@implementation JSONConverter
- (NSDictionary *)convert:(id<JSONConvertible>)object {
    return [object toJSON];
}
@end

测试验证 #

Type1 *type1Obj = [[Type1 alloc] initWithMember1:@"someValue1" member2:@"someValue2"];
NSLog(@"%@", convertToJSON(type1Obj)); // 输出 {"member1":"someValue1","member2":"someValue2"}

Type2 *type2Obj = [[Type2 alloc] initWithMember3:@"someValue3" member4:@"someValue4"];
JSONConverter<Type2> *converter = [[JSONConverter alloc] init];
NSLog(@"%@", [converter convert:type2Obj]); // 输出 {"member3":"someValue3","member4":"someValue4"}

如果要转成JSON字符串，可以加个工具方法：

NSString *JSONStringFromDictionary(NSDictionary *dict) {
    NSError *error;
    NSData *data = [NSJSONSerialization dataWithJSONObject:dict options:NSJSONWritingPrettyPrinted error:&error];
    if (error) {
        NSLog(@"JSON转换失败：%@", error);
        return nil;
    }
    return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
}

// 调用示例
NSLog(@"%@", JSONStringFromDictionary(convertToJSON(type1Obj)));

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