iOS代码耦合的处理

耦合是每个程序员都必须面对的话题,也是容易被忽视的存在,怎么处理耦合关系到我们最后的代码质量。今天Peak君和大家聊聊耦合这个基本功话题,一起捋一捋iOS代码中处理耦合的种种方式及差异。

简化场景

耦合的话题可大可小,但原理都是相通的。为了方便讨论,我们先将场景进行抽象和简化,只讨论两个类之间的耦合。

假设我们有个类Person,需要喝水,根据职责划分,我们需要另一个类Cup来完成喝水的动作,代码如下:

//Person.h
@interface Person : NSObject
- (void)drink;
@end
 
//Cup.h
@interface Cup : NSObject
- (id)provideWater;
@end

很明显,Person和Cup之间要配合完成喝水的动作,是无论如何都会产生耦合的,我们来看看在Objective C下都有哪些耦合的方式,以及不同耦合方式对以后代码质量变化的影响。

方式一:.m引用

这种方式直接在.m文件中导入Cup.h,同时生成临时的Cup对象来调用Cup中的方法。代码如下:

#import "Person.h"
#import "Cup.h"

@implementation Person

- (void)drink {
    Cup* c = [Cup new];
    
    id water = [c provideWater];
    [self sip:water];
}

- (void)sip:(id)water
{
    //sip water
}

@end

这应该是不少同学会选择的做法,要用到某个类的功能,就import该类,再调用方法,功能完成提交测试一气呵成。

这种方式初看起来没什么毛病,但有个弊端:Person与Cup的耦合被埋进了Person.m文件的方法实现中,而.m文件一般都是业务逻辑代码的重灾区,当Person.m的代码量膨胀之后,如果Person类交由另一位工程师来维护,那这位新接手的同学无法从Person.h中一眼看出Person类和哪些类之间有交互,即使在Person.m中看drink的声明也没有任何线索,要理清楚的话,只能把Person.m文件从头到尾读一遍,对团队效率的影响可想而知。

方式二:.h Property

既然直接在.m中引用会导致耦合不清晰,我们可以将耦合的部分放入Property中,代码如下:

//Person.h
@interface Person : NSObject
@property (nonatomic, strong) Cup*                 cup;
- (void)drink;
@end
  
//Person.m
@implementation Person
- (void)drink {
    id water = [self.cup provideWater];
    [self sip:water];
}

- (void)sip:(id)water
{
    //sip water
}
@end

这样,我们只需要扫一眼Person.h就能明白,Person类对哪些类产生了依赖,比直接在.m中引用清晰多了。

不知道大家有没有好奇过,为什么在Objective C中会有.h文件的存在,为什么不像Java,Swift一样一个文件代表一个类?使用.h文件有利有弊。

.h文件最大的意义在于将声明实现相隔离。声明是告诉外部我支持哪些功能,实现是支撑这些功能背后的代码逻辑。在我们阅读一个类的.h文件的时候,它最主要的作用是透露两个信息:

  • 我(Person类)依赖了哪些外部元素
  • 我(Person类)提供哪些接口供外部调用

所以.h文件应该是我们代码耦合的关键所在,当我们犹豫一个类的Property要不要放到.h文件中去声明时,要思考这个Property是不是必须暴露给外部。一旦暴露到.h文件中,就增加了依赖和耦合的几率。有时候Review代码,只要看.h文件是否清晰,就大概能猜测这个类设计者的水平。

当我们把Cup类做为Person的Property声明时,就表明Person与Cup之间存在必要的依赖,我们把这种依赖放到头文件中来,起到一目了然的效果。这比方式一清晰了不少,但有另一个问题,Cup暴露出去以后,外部元素可以随意修改,当内部执行drink的时候,可能另一个线程将cup置空了,影响正常的业务流程。

方式三:.h ReadOnly Property

方式二中,Person类在对Cup产生依赖的同时,也承担了cup随时被外部修改的风险。当然做直观的做法是将Cup类作为ReadOnly的property,同时提供一个对外的setter:

//Person.h
@interface Person : NSObject
@property (nonatomic, strong, readonly) Cup*                 cup;
- (void)setPersonCup:(Cup*)cup;
- (void)drink;
@end

有同学可能会问,这和上面的做法有什么区别,不一样都有读写的接口吗?最大的区别是增加了检查和干扰的入口。

当我Debug的时候,经常需要检查某个Propery到底是被谁修改了,Setter中设置一个断点调试起来方便不少。同时,我们还可以使用Xcode的Caller机制,查看当前Setter都被那些外部类调用了,分析类与类之间的关联是很有帮助。

Person.m中Setter方法还提供了我们拓展功能的入口,比如我们需要在Setter中增加多线程同步Lock,当Person.m中的其他方法在使用Cup时,Setter必须等待完成才能执行。又比如我们可以在Setter中实现Copy On Write机制:

//Person.m
- (void)setPersonCup:(Cup*)cup {
    Cup* anotherCup = [cup copy];
    _cup = anotherCup;
}

这样,Person类就可以避免和外部类共享同一个Cup,杜绝使用同一个水杯的卫生问题 ;)

总之,单独的Setter方法让我们对代码有更大的掌控能力,也为后续接手维护你代码的同学带来了方便,利己利人。

方式四:init 注入

使用带Setter的Property虽然看上去好了不少,但Setter方法可以被任意外部类随时随刻调用,对于Person.m中使用Cup的方法来说,多少有些不安心,万一用着用着被别人改了呢?

为了避免被随意修改,我们可以采用init注入的方式,Objective C中的designated initializer正是为此而生:

//Person.h
@interface Person : NSObject
- (instancetype)initWithCup:(Cup*)cup;
- (void)drink;
@end

去掉Property,将Cup的设置放入init方法中,这样Person类对外就只提供一次机会来设置Cup,init之后,外部类就没有其他机会来修改Cup了。

这是使用最多,也是比较推荐的方式。只在对象被创建的时候,去建立与其他对象的关系,把可变性降低到一定程度。那这种方式是否也有什么缺点呢?

通过init的方式设置cup,杜绝了外部因素的影响,但如果内部持有了cup对象,那么内部的函数调用依然可以通过各种姿势与Cup类产生耦合,比如:

//Person.m
@interface Person ()
@property (nonatomic, strong) Cup*                 myCup;
@end

@implementation Person
- (instancetype)initWithCup:(Cup*)cup {
    self = [super init];
    if (self) {
        self.myCup = cup;
    }
    return self;
}

- (void)drinkWater {
    id water = [self.myCup provideWater];
    [self sip:water];
}

- (void)drinkMilk {
    id milk = [self.myCup provideMilk];
    [self sip:milk];
}

@end

Person内部的方法可以通过Cup所有对外的接口来产生耦合,此时我们对于两个类之间的耦合,就主要靠对Cup.h头文件来解读了。如果Cup类设计合理,头文件结构清晰的话,这其实不算太糟糕的场景。那还有没有其他方式呢?

方式五:parameter 注入

用Property持有的方式,在Person对象的整个生命周期内,耦合的可能性一直存在,原因在于Property对于.m文件来说是全局可见的。我们可以用另一种方式让耦合只发生在单个方法内部,即parameter injection:

//Person.h
@interface Person : NSObject
- (void)drink:(Cup*)cup;
@end
  
//Person.m
- (void)drink:(Cup*)cup {
    id water = [cup provideWater];
    [self sip:water];
}

这种方式的好处在于:Person和Cup的耦合只发生在drink函数的内部,一旦函数调用结束,Person和Cup之间就结束了依赖关系。从时间和空间的跨度上来说,这种方式比持有Property风险更小。

可要是在Person中存在多处Cup的依赖,比如有drinkWater,drinkMilk,drinkCoffee等等,反而又不如Property直观方便了。

方式六:单例引用

单例的优劣有很多优秀的技术文章分析过了,Peak君只强调其中一点,也是平时review代码和Debug发现最多的问题缘由:单例中的状态共享

上面的例子中,我们可以把Cup做成单例,代码如下:

//Person.m
- (void)drink {
    id water = [[Cup sharedInstance] provideWater];
    [self sip:water];
}

这种方式产生的耦合不但和方式一同样隐蔽,而且是最容易导致代码降级的,随着版本的不停迭代,我们很有可能会得到下面的一个类关联图:

所有的对象都依赖于同一个对象的状态,所有的对象都对这个对象的状态拥有读写权限,最后的结果很有可能是到处打补丁修Bug,按下葫芦浮起瓢。

使用单例类似的场景很常见,比如我们在单例中持有某个用户的信息,在用户登出之后,忘记清除之前用户的信息就会导致奇怪的bug,而且单例一旦零散的分布在项目的各个角落,要逐一处理十分困难。

方式七:继承

继承是一种强耦合关系,网络上有不少关于继承(inheritance)和组合(compoisition)之间优劣的对比文章了,这里不做赘述。继承确实能在初期很方便的建立清晰的对象模型,重用和多态看着也很美妙,问题在于这种强耦合关系在理解上很容易产生分歧,比如什么样对象之间可以被确立为父子关系,哪些子类的行为可以放到父类中给其他子类使用,在多层继承的时候这些问题会变得更加复杂。所以Peak君建议尽可能的少用继承关系来描述对象,除非是一目了然毫无异议的父子关系。

我就不强行来一波父类定义来举例了,比如什么ObjectWithCup这类。

方式八:runtime依赖

使用runtime来处理耦合是Objective C独特的方式,而且耦合度非常之低,甚至可以说感觉不到耦合的存在,比如:

//Person.m
- (void)drink:(id)obj
{
    id water = nil;
    SEL sel = NSSelectorFromString(@"provideWater");
    if ([obj respondsToSelector:sel]) {
        water = [obj performSelector:sel];
    }
    if (water) {
      [self sip:water];
    }
}

既不需要导入Cup的头文件,也不需要知道Cup到底支持哪些方法。这种方式的问题也正是由于耦合度太低了,让开发者感知不到耦合的存在,感知不到类之间的关系。如果哪天有人把provideWater改写成getWater,drink方法如果没有同步到,Xcode编译时不会提示你,runtime也不会crash,但是业务流程却没有正常往下走了。

这也是为什么我们不推荐用Objective-C runtime的黑魔法去做业务,只是在无副作用的场景下去完成一些数据的获取操作,比如使用AOP去log日志。

方式九:protocol依赖

这并不是一种独立的耦合方式,protocol可以结合上述各种耦合方式来进一步降低耦合,也是在复杂类关系设计中推荐的方式,比如我们可以定义这样一个protocol:

@protocol LiquidContainer <NSObject>

- (id)provideWater;
- (id)provideCoffee;

@end
  
//Person.h
@interface Person : NSObject

- (void)drink:(id<LiquidContainer>)container;

@end

上述的方式中,无论是Property持有还是parameter注入,都可以使用protocol来降低依赖,protocol的好处在于他只规定了方法的声明,并不限定具体是那个类来实现它,给后期的维护留下更大的空间和可能性。有关protocol的用处和重要性可以单独开一篇文章来讲。

更复杂的场景

以上是一些常见的类耦合方式,描述的两个类A,B之间的耦合方式。从上面的描述中,我们可以大致感知到两个类使用不同的方式所导致的耦合的深浅,这种耦合深浅度说白了就是:互相调用函数和访问状态的频次。理解这种耦的深浅可以帮助我们大致去量化两个对象之间的耦合度,从而在更复杂的场景中去分析一个模块或者一种架构方式的耦合度。

在更复杂的场景中,比如A,B,C三个类之间也可以采用类似的方法去分析,A,B,C三者可以是如下关系:

分析三个类或者更多类之间的耦合关系的时候,也是先拆解成若干个两个类分析,比如左边我们分析AB,BC,AC三组耦合,进而去感知ABC作为一个整体的耦合度。很显然,右边的方式看着比左边的好,因为只需要分析AB和BC。在我们选用设计模式重构代码的时候,也可以依照类似的方式来分析,从而选择耦合度最低,最贴合我们业务场景的模式。

我们的原则是:类与类之间调用的方法,依赖的状态要越少越好,在Objective C这门语言环境下,书写分类清晰,接口简洁的头文件非常重要。

良性的耦合

前面的分析重在尝试去量化和感知耦合的深浅,但并不是每一次方法调用都是有风险的,有些耦合可以称作是良性的。

如果将我们的代码进行高度抽象,所有的代码都可以被归为两类:Data和Action。一个Class中的Property是Data,而Class中的函数则是Action,我之前写过的一篇关于函数式的文章中提到过,真正让我们代码变得危险的是状态的变化,即改变Data。如果一个函数是纯函数,既不依赖于外部状态,也不修改外部状态,那么这个函数无论被调用多少次都是安全的。如果两个类,比如上面举例的Person和Cup,二者互相调用的都是纯函数,那么二者之间的耦合可以看做是良性的,并不会导致程序的状态维护混乱,只是会让代码的重构变得困难,毕竟耦合的越深,重构改动的代码就越多。

所以我们在做设计的时候,应该尽可能使不同元素之间的耦合是良性的,这就涉及到状态的维护问题,先看下图中两种不同的设计方式:

图中红色的圆圈代表每个类或者功能单位所持有的状态。依照图中上方的设计方式,每个单位各自处理自己的状态变化,这些状态之间还互相存在依赖的话,耦合越深,开发调试和重构就越难,代码就降级越厉害。如果按照图中下方的方式,将状态变化的部分全部都集中到一起处理,维护起来就轻松很多了,这也是为什么很多App都有model layer这一设计的原因,将App状态(各类model)的变化处理独立出来作为一个layer,上层(业务层)只是作为model layer的展现和交互的外壳。这种设计技巧,大可以应用于一个App架构的处理,小可以到一个小功能模块的设计。

结束语

上面总结了我们常用的一些耦合方式,目的在于分析不同代码的书写方式,对于我们最后耦合所产生的影响。最后值得一提的是,上面有些耦合方式并没有绝对的优劣之分,不同的业务场景下可能选择的方式也不同,比如有些场景确实需要持有Property,有些场景单例更合适,关键在于我们能明白不同方式对于我们代码后期维护所产生的影响,这篇文章有些地方可能比较抽象,其中很多都是个人感悟和总结,或有不妥之处,请阅读之后选择性的吸收,希望能对大家平常写代码处理耦合带来一些帮助。

欢迎关注公众号:MrPeakTech