设计模式 —— 中介模式（解藕）

设计模式 —— 中介模式

原理：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显示的相互引用，从而使其耦合度降低，而且可以独立的改变他们之间的交互 (将网状结构转换为线型结构，减少耦合)

解决的问题：将网状结构转换为线型结构，减少耦合；增加可维护性；降低复杂度；

使用方法：

可用代理——继承方法
委托方创建协议；
创建父类中介类，并遵守协议;
在子类中实现不同的功能

1、委托方定协议(父类)

.h
#import <Foundation/Foundation.h>
@class AbstructCollege;

@protocol CollegeDelegate <NSObject>
@optional//可选择
- (void)collegeEvent:(AbstructCollege *)college;
@end

@interface AbstructCollege : NSObject
@property (nonatomic,weak) id <CollegeDelegate> delegate;
@end


.m
#import "AbstructCollege.h"

@implementation AbstructCollege
@end

2、中介器（父类）

.h
//遵守协议
#import <Foundation/Foundation.h>
#import "AbstructCollege.h"

@interface AbstructMediort : NSObject <CollegeDelegate>
@end


.m
//实现代理
#import "AbstructMediort.h"

@implementation AbstructMediort
- (void)collegeEvent:(AbstructCollege *)college {
    
}
@end

3、委托方子类对象

.h
#import <UIKit/UIKit.h>
#import "AbstructCollege.h"

@interface College : AbstructCollege
@property (nonatomic,assign) CGFloat value;
- (void)changeValue:(CGFloat)value;
@end

.m
#import "College.h"

@implementation College
- (void)changeValue:(CGFloat)value {
    self.value = value;
    if (self.delegate && [self.delegate respondsToSelector:@selector(collegeEvent:)]){
        [self.delegate collegeEvent:self];
    }
}
@end

4、中介器子类1(如果规则有改变可以再创建对应的子类中介器)

.h
#import "AbstructMediort.h"
#import "College.h"

@interface TypeOneMediator : AbstructMediort
@property (nonatomic,strong) College *colleagueA;
@property (nonatomic,strong) College *colleagueB;
@property (nonatomic,strong) College *colleagueC;
- (NSDictionary *)values;//查看打印信息
@end

.m
#import "TypeOneMediator.h"

@implementation TypeOneMediator

- (void)collegeEvent:(AbstructCollege *)college {
    if ([college isEqual:self.colleagueA]) {
        self.colleagueB.value = self.colleagueA.value * 2;
        self.colleagueC.value = self.colleagueA.value * 4;
    } else if ([college isEqual:self.colleagueB]) {
        self.colleagueA.value = self.colleagueB.value / 2;
        self.colleagueC.value = self.colleagueB.value * 2;
    } else {
        self.colleagueA.value = self.colleagueC.value / 4;
        self.colleagueB.value = self.colleagueC.value / 2;
    }
}

- (NSDictionary *)values {
    return @{@"A":@(self.colleagueA.value),
             @"B":@(self.colleagueB.value),
             @"C":@(self.colleagueC.value),
             };
}

5、调用时不必处理对象间的复杂逻辑判断，直接交给中介器处理

self.typeOne = [[TypeTwoMediator alloc] init];
    
College *colleagueA = [[College alloc] init];
College *colleagueB = [[College alloc] init];
College *colleagueC = [[College alloc] init];
    
self.typeOne.colleagueA = colleagueA;
self.typeOne.colleagueB = colleagueB;
self.typeOne.colleagueC = colleagueC;
    
colleagueA.delegate = self.typeOne;
colleagueB.delegate = self.typeOne;
colleagueC.delegate = self.typeOne;
    
[colleagueA changeValue:4];
NSLog(@"%@",self.typeOne.values);