A股上市公司传智教育（股票代码 003032）旗下技术交流社区北京昌平校区

传智教育官网黑马程序员官网

 找回密码
 加入黑马

QQ登录

只需一步，快速开始

论坛首页 › 学习交流 › 免费资源 › iOS资源 › 正文

IoC在Objective-C中的实现

© Simpon 中级黑马   /  2016-5-19 17:00  /  1370 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 Simpon 于 2016-10-19 11:44 编辑

•    IoC简介
1、IoC的基本概念
IoC是Inversion of Control（控制反转）的英文缩写，它是在面向对象编程中用来降低计算机应用程序耦合度的一个重要的设计思想。
2、如何理解IoC
接下来通过一个简单的例子来理解究竟什么是IoC。
陈某希如何找女朋友?
通常情况下，我们都是根据自己的需求，确定自己在什么时候需要女朋友，以及需要什么样的女朋友。
对应到代码中，体现如下：
  1. #import <Foundation/Foundation.h>
  2. #import " ZhouMouTong.h"

  4. @interface ChenMouXi: NSObject
  5. @property(nonatomic,strong) ZhouMouTong *gf;
  6. @end
复制代码


不难发现，这个时候对ChenMouXi 类和ZhouMouTong类进行了强关联，ChenMouXi对ZhouMouTong直接耦合在了一起。
但是我们知道，某希哥换女朋友的速度是无可比拟的，所以这么在代码中这么些明显不够明智，因为一旦某希哥需要换女友，我们就需要对某希哥的代码进行更改，重新建立关系。鉴于这种情况，就需要给某希哥找一个助理，当某希哥需要女朋友的时候，将要找女朋友的标准告诉助理，然后助理将合适的女朋友交给某希哥。
所以我们选择用如下的方式来修改当前的代码:
  1. #import <Foundation/Foundation.h>
  2. #import " ZhouMouTong.h"
  3. @protocol Girlfriend <NSObject>
  4. - (void)takePicture;
  5. - (void)sleep;
  6. @end

  8. @interface Assistant : NSObject
  9. - (id<Girlfriend>)findGirlfriend;
  10. @end

  12. @implementation Assistant
  13. - (id<Girlfriend>)findGirlfriend{
  14.      //助手在这个方法内为冠希哥找女朋友并返回
  15. }
  16. @end

  18. @interface ChenMouXi: NSObject
  19. @property(nonatomic,strong) id<Girlfriend> gf;
  20. @end

  22. @implementation ChenMouXi
  23. - (instancetype)init
  24. {
  25.     self = [super init];
  26.     if (self) {
  27.         //在这里，当某希哥需要女朋友的时候，由助手找一个满足要求的妹子对象
  28.           Assistant *ass = [Assistant new];
  29.         self.gf = [ass findGirlfriend];
  30.     }
  31.     return self;
  32. }
  33. @end
  34. #import <Foundation/Foundation.h>
  35. #import " ZhouMouTong.h"
  36. @protocol Girlfriend <NSObject>
  37. - (void)takePicture;
  38. - (void)sleep;
  39. @end

  41. @interface Assistant : NSObject
  42. - (id<Girlfriend>)findGirlfriend;
  43. @end

  45. @implementation Assistant
  46. - (id<Girlfriend>)findGirlfriend{
  47.      //助手在这个方法内为冠希哥找女朋友并返回
  48. }
  49. @end

  51. @interface ChenMouXi: NSObject
  52. @property(nonatomic,strong) id<Girlfriend> gf;
  53. @end

  55. @implementation ChenMouXi
  56. - (instancetype)init
  57. {
  58.     self = [super init];
  59.     if (self) {
  60.         //在这里，当某希哥需要女朋友的时候，由助手找一个满足要求的妹子对象
  61.           Assistant *ass = [Assistant new];
  62.         self.gf = [ass findGirlfriend];
  63.     }
  64.     return self;
  65. }
  66. @end
复制代码


当进行如上修改之后，通过加入一个助手类，使得ChenMouXi类和女朋友类之间进行了解耦。
通过上面的例子，我们就可以理解IoC的概念了，IoC全称是什么？控制反转，分解开来看，关键有两个:
一个是控制，一个是反转。
那我们就要问了，这个控制具体指代什么？
对应上面的例子，所谓的控制，就是指为某希哥指定女朋友的控制权，在一开始的时候，这个控制权是掌握在某希哥自己手里的。
那反转呢？控制怎么就反转了？
同样，对应上面的例子，在对代码进行更改之后，我们将为某希哥指定女友的控制权进行了移交，交给了一个助手类。
            控制反转，对于软件来说，就是某一协议具体实现类的选择控制权（创建对象的控制权）从调用类中移除，转交给第三方决定。
•    Objective-C中IoC的具体实现
•    实现思路分析
控制反转(IoC)就是将创建对象的控制权交给第三方，所以现在要做的事情就是创建出来这个拥有控制权的第三方。
首先，这个类需要根据不同的需求在适当的时候创建合适的对象。所以创建对象是这个类最重要的功能，那么如何在程序中众多的类中精确的找到当前所需要的类来创建对应的对象呢？
如上所述，需要根据不同的需求来创建对象，那么对所需要的对象的需求描述，在OC中我们可以使用protocol。
接下来，我将描述这个第三方类的具体实现思路:
首先，在程序中并不是所有的类都需要进行IoC控制，所以我们要对需要进行IoC控制的类进行标记，这里我选择用protocol进行标记，也就是让对应的类遵守指定的协议。
在第三方类创建的时候，读取应用程序中所有的类并遍历，依次根据之前写好的标记，来判断当前类是否需要进行IoC控制，将其缓存进一个临时数组。
此时，已经有了所有需要进行IoC控制的类，但是如何通过不同的需求来定位到指定的类呢？
数组并不能进行有效的查询工作，所以需要对该数组进行再次处理，将数组内的存储的类用描述需求的协议名称做键，将实现了该协议的所有类存入数组做为该键对应的值，以键值对的形式存入字典内，方便之后进行对应的查询工作。
当以上工作全部完成之后，要做的事情，就是为第三方类，封装根据不同需求（也就是协议）创建对象的方法。当用户传入一个协议名称，或者一个协议的时候，根据用户传入的协议，在字典中找到对应的类，创建对象进行返回，就完成了IoC的基本功能。
•    具体实现步骤
•    标记协议创建
这个协议只是一个单纯的标记作用，所以无所谓功能，创建一个空的协议就好
  1.           @protocol InjectedClassProtocol <NSObject>

  3. @end
  4. @protocol InjectedClassProtocol <NSObject>

  6. @end
复制代码

•    创建拥有控制权的第三方类
  1.             @interface Injector : NSObject

  3. @end
  4. @interface Injector : NSObject

  6. @end
复制代码
这个类是要在整个应用程序中肩负起创建对象的重任，所以这个类必然要使用单例来创建对象。
所以需要给这个类添加两个方法，来获取单例对象
  
  1.         /**
  2. *  获取全局注入器
  3. *
  4. *  @return 返回全局注入器
  5. */
  6. + (Injector *)sharedInstance;

  8. /**
  9. *  获取全局注入器
  10. *
  11. *  @return 返回全局注入器
  12. */
  13. - (Injector *)sharedInstance;

  15. /**
  16. *  获取全局注入器
  17. *
  18. *  @return 返回全局注入器
  19. */
  20. + (Injector *)sharedInstance;

  22. /**
  23. *  获取全局注入器
  24. *
  25. *  @return 返回全局注入器
  26. */
  27. - (Injector *)sharedInstance;
复制代码

这个类主要的功能就是，根据不同的用户需求（协议）,来创建指定的对象，所以需要有对应的方法来做这件事情。
      
  1.      /**
  2. *  通过协议名称查询实现协议类的实例
  3. *
  4. *  @param protocol 协议字名称
  5. *
  6. *  @return 返回实现协议类的实例，如果没有找到返回 nil
  7. */
  8. - (id)instanceForProtocolName:(NSString *)protocolName;

  10. /**
  11. *  通过协议查询实现协议类的实例
  12. *
  13. *  @param protocol 协议
  14. *
  15. *  @return 返回实现协议类的实例，如果没有找到返回 nil
  16. */
  17. - (id)instanceForProtocol:(Protocol *)protocol;

  19. /**
  20. *  通过协议名称查询实现协议类的实例的集合
  21. *
  22. *  @param protocol 协议
  23. *
  24. *  @return 返回协议实现类的实例的集合
  25. */
  26. - (NSArray *)instancesForProtocolName:(NSString *)protocolName;

  28. /**
  29. *  通过协议查询实现协议类的实例的集合
  30. *
  31. *  @param protocol 协议
  32. *
  33. *  @return 返回协议实现类的实例的集合
  34. */
  35. - (NSArray *)instancesForProtocol:(Protocol *)protocol;
  36. /**
  37. *  通过协议名称查询实现协议类的实例
  38. *
  39. *  @param protocol 协议字名称
  40. *
  41. *  @return 返回实现协议类的实例，如果没有找到返回 nil
  42. */
  43. - (id)instanceForProtocolName:(NSString *)protocolName;

  45. /**
  46. *  通过协议查询实现协议类的实例
  47. *
  48. *  @param protocol 协议
  49. *
  50. *  @return 返回实现协议类的实例，如果没有找到返回 nil
  51. */
  52. - (id)instanceForProtocol:(Protocol *)protocol;

  54. /**
  55. *  通过协议名称查询实现协议类的实例的集合
  56. *
  57. *  @param protocol 协议
  58. *
  59. *  @return 返回协议实现类的实例的集合
  60. */
  61. - (NSArray *)instancesForProtocolName:(NSString *)protocolName;

  63. /**
  64. *  通过协议查询实现协议类的实例的集合
  65. *
  66. *  @param protocol 协议
  67. *
  68. *  @return 返回协议实现类的实例的集合
  69. */
  70. - (NSArray *)instancesForProtocol:(Protocol *)protocol;
复制代码

•    根据标记协议读取所有需要进行IoC控制的类
在前面分析实现思路的时候提到过，首先要获取程序中所有的需要进行IoC控制的类。
第一步，获取程序中所有的类（objc_getClassList函数）
第二步，遍历所有的类，判断是否需要进行IoC控制（class_conformsToProtocol函数）
第三步，将所有需要进行IoC控制的类添加到临时数组并返回该数组
  
  1.          - (NSArray *)queryInjectedClasses {
  2.     NSMutableArray* injectedClasses = [NSMutableArray array];
  3.     int numClasses;
  4.     Class * classes = NULL;
  5.     classes = NULL;
  6.     numClasses = objc_getClassList(NULL, 0);
  7.     if (numClasses > 0 )
  8.     {
  9.         Protocol* iocProtocol = @protocol(InjectedClassProtocol);
  10.       
  11.         classes = (Class *)malloc(sizeof(Class) * numClasses);
  12.       
  13.         numClasses = objc_getClassList(classes, numClasses);
  14.         for (NSInteger i = 0; i < numClasses; i++)
  15.         {
  16.             Class cls = classes[i];
  17.            
  18.             for ( Class thisClass = cls; nil != thisClass ; thisClass = class_getSuperclass( thisClass ) )
  19.             {
  20.                 if(class_conformsToProtocol(thisClass, iocProtocol)) {
  21.                     [injectedClasses addObject:cls];
  22.                 }
  23.             }
  24.         }
  25.         free(classes);
  26.     }
  27.     return injectedClasses;
  28. }
  29. - (NSArray *)queryInjectedClasses {
  30.     NSMutableArray* injectedClasses = [NSMutableArray array];
  31.     int numClasses;
  32.     Class * classes = NULL;
  33.     classes = NULL;
  34.     numClasses = objc_getClassList(NULL, 0);
  35.     if (numClasses > 0 )
  36.     {
  37.         Protocol* iocProtocol = @protocol(InjectedClassProtocol);
  38.       
  39.         classes = (Class *)malloc(sizeof(Class) * numClasses);
  40.       
  41.         numClasses = objc_getClassList(classes, numClasses);
  42.         for (NSInteger i = 0; i < numClasses; i++)
  43.         {
  44.             Class cls = classes[i];
  45.            
  46.             for ( Class thisClass = cls; nil != thisClass ; thisClass = class_getSuperclass( thisClass ) )
  47.             {
  48.                 if(class_conformsToProtocol(thisClass, iocProtocol)) {
  49.                     [injectedClasses addObject:cls];
  50.                 }
  51.             }
  52.         }
  53.         free(classes);
  54.     }
  55.     return injectedClasses;
  56. }
复制代码

•    存储读取到的类
为方便之后进行对应的查询工作，对上一步数组进行再次处理，通过遍历，将数组内的存储的类用描述需求的协议名称做键，将实现了该协议的所有类存入数组做为该键对应的值，以键值对的形式存入字典内。这一过程称之为注册IoC类。
所以这里需要给类新增一个私有的字典属性。
  1. NSMutableDictionary*    _injectedClasses;
  2. NSMutableDictionary*    _injectedClasses;
复制代码


接下来注册类：
  1.            - (void)registerInjectedClass:(Class)cls {
  2.     uint protocolListCount = 0;
  3.     //获取当前遍历的类所实现的所有协议
  4.     Protocol * const *pArrProtocols = class_copyProtocolList(cls,&protocolListCount);
  5.     if(pArrProtocols != NULL && protocolListCount > 0) {
  6.         for (int i = 0; i < protocolListCount; i++) {
  7.             Protocol *protocol = *(pArrProtocols + i);
  8.             //将类存入字典中该协议所对应的数组中
  9.             [self bindProtocol:protocol Class:cls];
  10.         }
  11.         free((void *)pArrProtocols);
  12.     }
  13. }

  15. - (void)bindProtocol:(Protocol *)protocol Class:(Class)cls {
  16.     if(protocol == nil) return;
  17.     //获取当前协议名称
  18.     NSString* protocolString = NSStringFromProtocol(protocol);
  19.     //如果遵守的协议是空，或者NSObject，或者是标记协议，则不做处理
  20.     if(protocolString == nil ||
  21.        [protocolString isEqualToString:@"NSObject"] ||
  22.        [protocolString isEqualToString:@"IntercepterProtocol"] ||
  23.        protocol_isEqual(protocol, @protocol(InjectedClassProtocol))) return;
  24.    
  25.     //查看该协议名称所对应的类数组是否存在
  26.     NSMutableArray *_protocolClasses = _injectedClasses[protocolString];
  27.     //若不存在，则创建新的数组
  28.     if(_protocolClasses == nil) {
  29.         _protocolClasses = [NSMutableArray array];
  30.         [_injectedClasses setObject:_protocolClasses forKey:protocolString];
  31.     }
  32.     //如果数组中已经包含了这个类，直接返回，什么事儿都不做
  33.     if([_protocolClasses containsObject:cls]) return;
  34.     [_protocolClasses addObject:cls];   
  35. }
  36. - (void)registerInjectedClass:(Class)cls {
  37.     uint protocolListCount = 0;
  38.     //获取当前遍历的类所实现的所有协议
  39.     Protocol * const *pArrProtocols = class_copyProtocolList(cls,&protocolListCount);
  40.     if(pArrProtocols != NULL && protocolListCount > 0) {
  41.         for (int i = 0; i < protocolListCount; i++) {
  42.             Protocol *protocol = *(pArrProtocols + i);
  43.             //将类存入字典中该协议所对应的数组中
  44.             [self bindProtocol:protocol Class:cls];
  45.         }
  46.         free((void *)pArrProtocols);
  47.     }
  48. }

  50. - (void)bindProtocol:(Protocol *)protocol Class:(Class)cls {
  51.     if(protocol == nil) return;
  52.     //获取当前协议名称
  53.     NSString* protocolString = NSStringFromProtocol(protocol);
  54.     //如果遵守的协议是空，或者NSObject，或者是标记协议，则不做处理
  55.     if(protocolString == nil ||
  56.        [protocolString isEqualToString:@"NSObject"] ||
  57.        [protocolString isEqualToString:@"IntercepterProtocol"] ||
  58.        protocol_isEqual(protocol, @protocol(InjectedClassProtocol))) return;
  59.    
  60.     //查看该协议名称所对应的类数组是否存在
  61.     NSMutableArray *_protocolClasses = _injectedClasses[protocolString];
  62.     //若不存在，则创建新的数组
  63.     if(_protocolClasses == nil) {
  64.         _protocolClasses = [NSMutableArray array];
  65.         [_injectedClasses setObject:_protocolClasses forKey:protocolString];
  66.     }
  67.     //如果数组中已经包含了这个类，直接返回，什么事儿都不做
  68.     if([_protocolClasses containsObject:cls]) return;
  69.     [_protocolClasses addObject:cls];   
  70. }
复制代码

•    实现查询方法
  1.           /**
  2. *  通过协议名称查询实现协议类的实例
  3. *
  4. *  @param protocol 协议字名称
  5. *
  6. *  @return 返回实现协议类的实例，如果没有找到返回 nil
  7. */
  8. - (id)instanceForProtocolName:(NSString *)protocolName {
  9.     if(protocolName == nil) return nil;
  10.    
  11.     //获取注入的类
  12.     NSMutableArray *_protocolClasses = _injectedClasses[protocolName];
  13.     if(_protocolClasses == nil || _protocolClasses.count == 0) return nil;
  14.     Class cls = _protocolClasses.firstObject;
  15.     if(cls == nil) {
  16.         return nil;
  17.     }
  18.     instance = [[cls alloc] init];
  19.     return instance;
  20. }

  22. /**
  23. *  通过协议名称查询实现协议类的实例
  24. *
  25. *  @param protocol 协议字名称
  26. *
  27. *  @return 返回实现协议类的实例，如果没有找到返回 nil
  28. */
  29. - (id)instanceForProtocolName:(NSString *)protocolName {
  30.     if(protocolName == nil) return nil;
  31.    
  32.     //获取注入的类
  33.     NSMutableArray *_protocolClasses = _injectedClasses[protocolName];
  34.     if(_protocolClasses == nil || _protocolClasses.count == 0) return nil;
  35.     Class cls = _protocolClasses.firstObject;
  36.     if(cls == nil) {
  37.         return nil;
  38.     }
  39.     instance = [[cls alloc] init];
  40.     return instance;
  41. }

  43.      /**
  44. *  通过协议查询实现协议类的实例
  45. *
  46. *  @param protocol 协议
  47. *
  48. *  @return 返回实现协议类的实例，如果没有找到返回 nil
  49. */
  50. - (id)instanceForProtocol:(Protocol *)protocol {
  51.     if(protocol == nil) return nil;
  52.     NSString* protocolName = NSStringFromProtocol(protocol);
  53.     if(protocolName == nil) return nil;
  54.     return [self instanceForProtocolName:protocolName];
  55. }
  56. /**
  57. *  通过协议查询实现协议类的实例
  58. *
  59. *  @param protocol 协议
  60. *
  61. *  @return 返回实现协议类的实例，如果没有找到返回 nil
  62. */
  63. - (id)instanceForProtocol:(Protocol *)protocol {
  64.     if(protocol == nil) return nil;
  65.     NSString* protocolName = NSStringFromProtocol(protocol);
  66.     if(protocolName == nil) return nil;
  67.     return [self instanceForProtocolName:protocolName];
  68. }
  69. /**
  70. *  通过协议名称查询实现协议类的实例的集合
  71. *
  72. *  @param protocol 协议
  73. *
  74. *  @return 返回协议实现类的实例的集合
  75. */
  76. - (NSArray *)instancesForProtocolName:(NSString *)protocolName {
  77.     NSMutableArray *instances = [NSMutableArray array];
  78.     if(protocolName == nil) return instances;
  79.    
  80.     //获取注入的类
  81.     NSMutableArray *_protocolClasses = _injectedClasses[protocolName];
  82.     if(_protocolClasses == nil || _protocolClasses.count == 0) return nil;
  83.    
  84.     for (Class cls in _protocolClasses) {
  85.         if(cls == nil) {
  86.             return nil;
  87.         }
  88.         instance = [[cls alloc] init];
  89.         [instances addObject:instance];
  90.     }
  91.     return instances;
  92. }

  94. /**
  95. *  通过协议名称查询实现协议类的实例的集合
  96. *
  97. *  @param protocol 协议
  98. *
  99. *  @return 返回协议实现类的实例的集合
  100. */
  101. - (NSArray *)instancesForProtocolName:(NSString *)protocolName {
  102.     NSMutableArray *instances = [NSMutableArray array];
  103.     if(protocolName == nil) return instances;
  104.    
  105.     //获取注入的类
  106.     NSMutableArray *_protocolClasses = _injectedClasses[protocolName];
  107.     if(_protocolClasses == nil || _protocolClasses.count == 0) return nil;
  108.    
  109.     for (Class cls in _protocolClasses) {
  110.         if(cls == nil) {
  111.             return nil;
  112.         }
  113.         instance = [[cls alloc] init];
  114.         [instances addObject:instance];
  115.     }
  116.     return instances;
  117. }

  119. /**
  120. *  通过协议查询实现协议类的实例的集合
  121. *
  122. *  @param protocol 协议
  123. *
  124. *  @return 返回协议实现类的实例的集合
  125. */
  126. - (NSArray *)instancesForProtocol:(Protocol *)protocol {
  127.     if(protocol == nil) return [NSMutableArray array];
  128.     NSString* protocolName = NSStringFromProtocol(protocol);
  129.     if(protocolName == nil) return [NSMutableArray array];
  130.     return [self instanceForProtocolName:protocolName];
  131. }
  132. /**
  133. *  通过协议查询实现协议类的实例的集合
  134. *
  135. *  @param protocol 协议
  136. *
  137. *  @return 返回协议实现类的实例的集合
  138. */
  139. - (NSArray *)instancesForProtocol:(Protocol *)protocol {
  140.     if(protocol == nil) return [NSMutableArray array];
  141.     NSString* protocolName = NSStringFromProtocol(protocol);
  142.     if(protocolName == nil) return [NSMutableArray array];
  143.     return [self instanceForProtocolName:protocolName];
  144. }
复制代码

•    重写构造方法
  1.           - (instancetype)init
  2. {
  3.     self = [super init];
  4.     if (self) {
  5.         _injectedClasses = [NSMutableDictionary dictionary];
  6.         //查询所有需要进行IoC控制的类
  7.         NSArray* injectedClasses = [self queryInjectedClasses];
  8.       
  9.         //向字典中注册需要进行IoC控制的类
  10.         [injectedClasses enumerateObjectsUsingBlock:^(id cls, NSUInteger idx, BOOL *stop) {
  11.             [self registerInjectedClass:cls];
  12.         }];
  13.     }
  14.     return self;
  15. }
  16. - (instancetype)init
  17. {
  18.     self = [super init];
  19.     if (self) {
  20.         _injectedClasses = [NSMutableDictionary dictionary];
  21.         //查询所有需要进行IoC控制的类
  22.         NSArray* injectedClasses = [self queryInjectedClasses];
  23.       
  24.         //向字典中注册需要进行IoC控制的类
  25.         [injectedClasses enumerateObjectsUsingBlock:^(id cls, NSUInteger idx, BOOL *stop) {
  26.             [self registerInjectedClass:cls];
  27.         }];
  28.     }
  29.     return self;
  30. }
复制代码

•    实现单例方法
  
  1.          /**
  2. *  获取全局注入器
  3. *
  4. *  @return 返回全局注入器
  5. */
  6. + (Injector *)sharedInstance {
  7.     static dispatch_once_t onceToken;
  8.     static Injector *injector;
  9.     dispatch_once(&onceToken, ^{
  10.         injector = [[[self class] alloc] init];
  11.     });
  12.     return injector;
  13. }

  15. /**
  16. *  获取全局注入器
  17. *
  18. *  @return 返回全局注入器
  19. */
  20. - (Injector *)sharedInstance {
  21.     return [Injector sharedInstance];
  22. }
  23. /**
  24. *  获取全局注入器
  25. *
  26. *  @return 返回全局注入器
  27. */
  28. + (Injector *)sharedInstance {
  29.     static dispatch_once_t onceToken;
  30.     static Injector *injector;
  31.     dispatch_once(&onceToken, ^{
  32.         injector = [[[self class] alloc] init];
  33.     });
  34.     return injector;
  35. }

  37. /**
  38. *  获取全局注入器
  39. *
  40. *  @return 返回全局注入器
  41. */
  42. - (Injector *)sharedInstance {
  43.     return [Injector sharedInstance];
  44. }
复制代码

•    使用示例
创建一个SomeProtocol协议
  
  1.          #import <Foundation/Foundation.h>
  2. @protocol SomeProtocol <NSObject>
  3. - (void)sayHi;
  4. @end
  5. #import <Foundation/Foundation.h>
  6. @protocol SomeProtocol <NSObject>
  7. - (void)sayHi;
  8. @end
复制代码

创建一个Person类
      
  1.     #import <Foundation/Foundation.h>
  2. #import "Injector.h"
  3. #import "SomeThing.h"
  4. //使用标记协议进行标记
  5. @interface Person : NSObject<InjectedClassProtocol,SomeProtocol>
  6. @end

  8. @implementation Person
  9. - (void)sayHi{
  10.     NSLog(@"Hello World");
  11. }
  12. @end
  13. #import <Foundation/Foundation.h>
  14. #import "Injector.h"
  15. #import "SomeThing.h"
  16. //使用标记协议进行标记
  17. @interface Person : NSObject<InjectedClassProtocol,SomeProtocol>
  18. @end

  20. @implementation Person
  21. - (void)sayHi{
  22.     NSLog(@"Hello World");
  23. }
  24. @end
复制代码

在main.m中使用IoC的方式获取对象
        
  1.    #import <Foundation/Foundation.h>
  2. #import "Person.h"

  4. int main(int argc, const char * argv[]) {
  5.     @autoreleasepool {
  6.         Injector *injector = [Injector sharedInstance];
  7.         Person *p = [injector instanceForProtocol:@protocol(SomeProtocol)];
  8.         [p sayHi];
  9.     }
  10.     return 0;
  11. }
  12. #import <Foundation/Foundation.h>
  13. #import "Person.h"

  15. int main(int argc, const char * argv[]) {
  16.     @autoreleasepool {
  17.         Injector *injector = [Injector sharedInstance];
  18.         Person *p = [injector instanceForProtocol:@protocol(SomeProtocol)];
  19.         [p sayHi];
  20.     }
  21.     return 0;
  22. }
复制代码

•    内容总结
本文只是简单的将IoC的模式进行了实现，但是实现仍有如下缺陷:
•    父类实现的协议，子类必然也会实现，如果通过父类实现的协议来获取对象，应该是可以得获取的，但是上文未实现。
•    通过类遵守的协议所继承的协议来获取对象，应该可以获取，但是上文未实现
•    通过协议获取对象，如果系统中存在多个遵守了该协议的类，那么拿到的只会是数组中第一个类所创建出来的对象，不合理。（可以通过配置文件来解决这个问题，类似于Spring）
下期文章，将对如上所述缺陷一一进行完善，敬请关注哦~


精华推荐:


0 个回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 加入黑马