4.架构设计(设计模式-工厂模式场景)

1.工厂方法模式定义?

定义一个用于创建对象的统一的接口(协议),然后由子类进行实现.
我只定义工厂规范,具体哪一个工厂,你就创建对应产品.
为什么这么做?
目的就是解除耦合

2.我们进行案例分析

• 第一种
  我们首先创建接口(协议)工厂

#import <Foundation/Foundation.h>
#import "IProduct.h"

//工厂接口(协议)
@protocol IFactory01 <NSObject>

//定义一个规范
-(id<IProduct>)createProduct;

接着创建接口(协议)产品

#import <Foundation/Foundation.h>

@protocol IProduct <NSObject>

//产品规范:实现由具体的产品决定
-(void)method;

@end

接着创建具体的产品1

#import <Foundation/Foundation.h>
#import "IProduct.h"
//具体产品1
@interface ConcreateProduct1 : NSObject<IProduct>
@end

#import "ConcreateProduct1.h"
@implementation ConcreateProduct1
-(void)method{
    NSLog(@"我是产品1");
}
@end

接着创建具体的产品2

#import <Foundation/Foundation.h>
#import "IProduct.h"

@interface ConcreateProduct2 : NSObject<IProduct>

@end

#import "ConcreateProduct2.h"
@implementation ConcreateProduct2
-(void)method{
    NSLog(@"我是产品2");
}
@end

我们创建具体工厂1

#import <Foundation/Foundation.h>
#import "IFactory01.h"
@interface ConcrateFactory1 : NSObject<IFactory01>
@end

#import "ConcrateFactory1.h"
#import "ConcreateProduct1.h"
#import "ConcreateProduct2.h"
@implementation ConcrateFactory1
-(id<IProduct>)createProduct{
    return  [[ConcreateProduct1 alloc]init];
}
@end

案例一:
客户端不需要关心到底是哪一个产品,我们只需要工厂,
目的解除耦合,和具体产品解除了耦合,
提高了开发效率

• 第二种

案例一:存在什么问题?
问题:这个产品由内部控制,我们如果希望创建由客户端决定,同时达到解耦合的目的,我们该怎么办呢?
其实解决办法呢?是我上一篇文章的解决办法,如果你看了,或许就明白了.我们的解决办法就是动态创建实例对象.

我们先创建工厂协议和产品协议

#import <Foundation/Foundation.h>
#import "IProcut02.h"
@protocol IFactory02 <NSObject>
//定义一个规范
-(id<IProcut02>)createProduct:(NSString *)productClassName;
@end

#import <Foundation/Foundation.h>
@protocol IProcut02 <NSObject>
//产品规范:实现由具体的产品决定
-(void)method;
@end

创建具体产品1 和2

#import <Foundation/Foundation.h>
#import "IProcut02.h"

@interface ConcrateProduct102 : NSObject<IProcut02>

@end

#import "ConcrateProduct102.h"

@implementation ConcrateProduct102

-(void)method{
    NSLog(@"我是产品1");
}

@end

#import <Foundation/Foundation.h>
#import "IProcut02.h"

@interface ConcrateProduct202 : NSObject<IProcut02>

@end

#import "ConcrateProduct202.h"

@implementation ConcrateProduct202

-(void)method{
    NSLog(@"我是产品2");
}

@end

创建具体工厂

#import <Foundation/Foundation.h>
#import "IFactory02.h"

#define PRODUCT_1_02 @"ConcrateProduct102"
#define PRODUCT_2_02 @"ConcrateProduct202"

@interface ConcrateFactory02 : NSObject<IFactory02>

@end

#import "ConcrateFactory02.h"

@implementation ConcrateFactory02

-(id<IProcut02>)createProduct:(NSString *)productClassName{
    
    return [[NSClassFromString(productClassName) alloc]init];
    
}

@end

案例二就做到了动态创建实例对象,我们只需要根据需要创建的产品,动态创建实例对象.

• 第三种

我们是否可以再次优化?
当然可以,我们选择工厂生产产品

先创建工厂协议与产品协议

#import <Foundation/Foundation.h>
#import "IProduct03.h"

@protocol IFactory03 <NSObject>

//定义一个规范
-(id<IProduct03>)createProduct;

@end

#import <Foundation/Foundation.h>

@protocol IProduct03 <NSObject>
//产品规范
-(void)method;

@end

创建具体产品1和具体工厂1

#import <Foundation/Foundation.h>
#import "IProduct03.h"

@interface ConcrateProduct103 : NSObject<IProduct03>

@end

#import "ConcrateProduct103.h"

@implementation ConcrateProduct103

-(void)method{
    
    NSLog(@"我是产品1");
}

@end

#import <Foundation/Foundation.h>
#import "IFactory03.h"

@interface ConcrateFactory103 : NSObject<IFactory03>

@end

#import "ConcrateFactory103.h"
#import "ConcrateProduct103.h"

@implementation ConcrateFactory103

//工厂1用于创建产品1
-(id<IProduct03>)createProduct{
    
    return [[ConcrateProduct103 alloc]init];
}

@end

创建具体产品2 和工厂产品2

#import <Foundation/Foundation.h>
#import "IProduct03.h"

@interface ConcrateProduct203 : NSObject<IProduct03>

@end

#import "ConcrateProduct203.h"

@implementation ConcrateProduct203

-(void)method{
    
    NSLog(@"我是产品2");
}

@end

#import <Foundation/Foundation.h>
#import "IFactory03.h"

@interface ConcrateFactory203 : NSObject<IFactory03>

@end

#import "ConcrateFactory203.h"
#import "ConcrateProduct203.h"

@implementation ConcrateFactory203
//工厂2用于创建产品2
-(id<IProduct03>)createProduct{
    
    return [[ConcrateProduct203 alloc]init];
}

@end

通过再次优化,选择具体工厂生产产品

第四种:

为了加深印象,我们再次举例.那我们生活中的案例进行扩展.

1.电脑协议2.电脑工厂3.具体产品4.具体工厂
首先创建电脑协议及电脑工厂

#import <Foundation/Foundation.h>
#import "IComputer.h"

@protocol IComputerFactory <NSObject>

//生产电脑
-(id<IComputer>)createComputer;

@end

#import <Foundation/Foundation.h>

//电脑规范
@protocol IComputer <NSObject>

//处理器
-(void)cpu;

//显卡
-(void)displaycard;

//主板
-(void)mainboard;

@end

接着创建具体工厂及具体产品

#import <Foundation/Foundation.h>
#import "IComputer.h"

@interface ComputerA : NSObject<IComputer>

@end

#import "ComputerA.h"

@implementation ComputerA
//处理器
-(void)cpu
{
    NSLog(@"Intel i7");
}

//显卡
-(void)displaycard
{
    NSLog(@"Intel 显卡");
}

//主板
-(void)mainboard
{
    NSLog(@"三星主板");
}

@end

#import <Foundation/Foundation.h>
#import "IComputerFactory.h"

@interface FactoryA : NSObject<IComputerFactory>

@end

#import "FactoryA.h"
#import "ComputerA.h"

@implementation FactoryA

-(id<IComputer>)createComputer{
    
    return [[ComputerA alloc]init];
}

@end

通过电脑工厂案例,你应该进一步了解了工厂方法模式的应用.

3.分析工厂方法模式:角色划分

第一个角色:抽象工厂
第二个角色:具体工厂
第三个角色:抽象产品
第四个角色:具体产品

4.工厂方法模式的UML图

工厂方法模式UML

具体产品实现抽象产品协议
具体工厂实现抽象工厂协议
具体工厂与具体产品之间存在依赖关系

5.总结

如果你了解了工厂方法模式,想一想自己做开发使用的代码?
如果单纯的创建实例的对象,我们那些方法是不是很low了.
我们通过改进我们的代码,不仅开发效率也提高了不少,解除了耦合度.
文章和代码会继续更新,代码整理放到github.
如果你喜欢这篇文章,能帮助到你,请你继续关注.