Objection源码解析

最新推荐文章于 2023-12-02 14:58:17 发布

敬业的程序猿

最新推荐文章于 2023-12-02 14:58:17 发布

阅读量590

点赞数

分类专栏： IOS

IOS 专栏收录该内容

85 篇文章 0 订阅

订阅专栏

一、简介

Objection是一个iOS中轻量级的对DI及IoC的实现，不知道DI及IoC的请移步至iOS组件通信方案，Objection只有Object-C版本，没有Swift版本，如果你想在Swift中使用这种容器框架，可以了解下Typhoon，二者对于DI的实现方式不同，原理也不同，本篇文章主要分析Objection。

它的优点有哪些呢？

支持我们进行面向接口编程，有利于项目解耦（组件化）。
对象的销毁由系统管理，而Objection可以帮助我们完成对象的创建工作。
其他优点自行体会。

二、关键词及其实现

提前了解关键词有助于我们更好的理解该框架的底层实现，Objection中的关键词有如下几个：

Annocation（注解）
KVC
runtime

1.先来说注解

Objection中的注解是通过宏定义来实现的，所以掌握注解的使用至关重要，这些宏定义全部放在了Objection.h文件中，包括如下几个：
（1）objection_register(value)
向容器中注册类（Class），未来使用的时候，容器会直接拿到这个类然后进行实例化。

（2）objection_register_singleton(value)
功能同（1），不过这里是注册单例。

（3）objection_requires(args...)
基于属性的注入方式依赖此宏，这个宏用于定义某个类进行实例化时所依赖的属性，如果这个属性所属的类是我们之前已经注入到容器中的，那么容器就会取出这个类的实例对象，并将实例对象赋值给这个属性。

（4）objection_requires_sel(args...)
这个也是基于属性的注入方式，和（3）是一样的，只不过在你获取或注入某个属性值的时候，会走getter方法。

（5）objection_requires_names(namedDependencies)
这个是对（3）的功能补充，用于给注入的属性起个别名。

（6）objection_initializer_sel(selectorSymbol, args...)
基于构造器的注入方式依赖此宏，这个宏用于定义某个类的初始化函数，可以看到展开后有两个参数，第一个参数是你自定义的初始化函数，第二个参数是个可变类型的参数，也就是你初始化函数所依赖的参数需要在这里指明，举个例子：

Person.m

- (instance)initWithName:(NSString *)name age:(NSString *)age {
   if(self = [super init]){
    self.name = name;
    self.age = age;
  }
  return self;
}

objection_initializer_sel(initWithName:age:)

（7）objection_initializer(selectorSymbol, args...)
这个宏内部会调用（6）

2.KVC

Objection中对于注入功能的实现是通过KVC来完成的，这也是容器完成创建实例对象的最后一步，如下所示。

- (id)buildObject:(NSArray *)arguments initializer: (SEL) initializer {
    
    id objectUnderConstruction = nil;
    
    if(initializer != nil) {
        objectUnderConstruction = JSObjectionUtils.buildObjectWithInitializer(self.classEntry, initializer, arguments);
    } else if ([self.classEntry respondsToSelector:@selector(objectionInitializer)]) {
        objectUnderConstruction = JSObjectionUtils.buildObjectWithInitializer(self.classEntry, [self initializerForObject], [self argumentsForObject:arguments]);
    } else {
        objectUnderConstruction = [[self.classEntry alloc] init];
    }

    if (self.lifeCycle == JSObjectionScopeSingleton) {
        _storageCache = objectUnderConstruction;
    }
    
     //最后一步：注入依赖的属性值！
    JSObjectionUtils.injectDependenciesIntoProperties(self.injector, self.classEntry, objectUnderConstruction);
    
    return objectUnderConstruction;
}

static void InjectDependenciesIntoProperties(JSObjectionInjector *injector, Class klass, id object) {
    if ([klass respondsToSelector:@selector(objectionRequires)]) {
        NSSet *properties = [klass objectionRequires];
        NSMutableDictionary *propertiesDictionary = [NSMutableDictionary dictionaryWithCapacity:properties.count];
        for (NSString *propertyName in properties) {
            JSObjectionPropertyInfo propertyInfo;
            id desiredClassOrProtocol;
            _getPropertyInfo(klass, propertyName, &propertyInfo, &desiredClassOrProtocol);
            id theObject = [injector getObject:desiredClassOrProtocol];
            _validateObjectReturnedFromInjector(&theObject, propertyInfo, desiredClassOrProtocol, propertyName);
            [propertiesDictionary setObject:theObject forKey:propertyName];
        }

        //使用KVC注入属性值
        [object setValuesForKeysWithDictionary:propertiesDictionary];
    }

    if ([klass respondsToSelector:@selector(objectionRequiresNames)]) {
        NSDictionary *namedProperties = [klass objectionRequiresNames];
        NSMutableDictionary *propertiesDictionary = [NSMutableDictionary dictionaryWithCapacity:namedProperties.count];
        for (NSString *namedPropertyKey in [namedProperties allKeys]) {
            NSString* propertyName = [namedProperties valueForKey:namedPropertyKey];
            JSObjectionPropertyInfo propertyInfo;
            id desiredClassOrProtocol;
            _getPropertyInfo(klass, propertyName, &propertyInfo, &desiredClassOrProtocol);
            id theObject = [injector getObject:desiredClassOrProtocol named:namedPropertyKey];
            _validateObjectReturnedFromInjector(&theObject, propertyInfo, desiredClassOrProtocol, propertyName);
            [propertiesDictionary setObject:theObject forKey:propertyName];
        }

        //使用KVC注入属性值
        [object setValuesForKeysWithDictionary:propertiesDictionary];
    }

    if ([object respondsToSelector:@selector(awakeFromObjection)]) {
        //如果对象重写了awakeFromObjection方法,这里还会调用awakeFromObjection方法，方便你做一些其他的操作
        [object awakeFromObjection];
    }
}

（3）runtime
方法的调用过程中使用了大量runtime技术，比如：

遍历类的属性
反射
消息传递

三、整体架构

了解其架构设计可以更好的帮助我们理解其实现原理。

我画了一个草图用来表示Objection主要的工作流程，如下：

流程图

1.总体流程

入口类是JSObjection，有几个常用的方法是：

+ (JSObjectionInjector *)createInjectorWithModules:(JSObjectionModule *)first, ... NS_REQUIRES_NIL_TERMINATION;
+ (JSObjectionInjector *)createInjectorWithModulesArray:(NSArray *)modules;
+ (JSObjectionInjector *)createInjector:(JSObjectionModule *)module;
+ (JSObjectionInjector *)createInjector;

通过这几个方法可以看出，JSObjection会根据若干个Module实例化出Injector对象，对应最左侧那一条流程，也就是JSObjection会收集所有Module对象，然后根据这些Module对象实例化出Injector对象。

对于开发者来说，操作JSObjectionModule对象可能是最常见的操作之一，顾名思义，JSObjectionModule代表一个模块，怎么划分模块任你设计，你可以将不同的页面划分成不同的模块，比如一个商品详情页面可以对应一个Module，一个会话详情页面可以对应一个Module；也可以将一条业务线划分成一个Module，比如商品Module可以包括列表、详情、订单等页面，一个即时通讯Module可以包括会话列表、会话详情、个人详情等页面。

JSObjectionModule包含哪些操作呢？很多很多，多到你用不过来。

- (void)bind:(id)instance toClass:(Class)aClass;
- (void)bind:(id)instance toClass:(Class)aClass named:(NSString *)name;
- (void)bind:(id)instance toProtocol:(Protocol *)aProtocol;
- (void)bind:(id)instance toProtocol:(Protocol *)aProtocol named:(NSString *)name;
- (void)bindMetaClass:(Class)metaClass toProtocol:(Protocol *)aProtocol;
- (void)bindProvider:(id<JSObjectionProvider>)provider toClass:(Class)aClass;
- (void)bindProvider:(id<JSObjectionProvider>)provider toClass:(Class)aClass named:(NSString *)name;
- (void)bindProvider:(id<JSObjectionProvider>)provider toProtocol:(Protocol *)aProtocol;
- (void)bindProvider:(id<JSObjectionProvider>)provider toProtocol:(Protocol *)aProtocol named:(NSString *)name;
- (void)bindProvider:(id<JSObjectionProvider>)provider toClass:(Class)aClass inScope:(JSObjectionScope)scope;
- (void)bindProvider:(id<JSObjectionProvider>)provider toClass:(Class)aClass inScope:(JSObjectionScope)scope named:(NSString *)name;
- (void)bindProvider:(id<JSObjectionProvider>)provider toProtocol:(Protocol *)aProtocol inScope:(JSObjectionScope)scope;
- (void)bindProvider:(id<JSObjectionProvider>)provider toProtocol:(Protocol *)aProtocol inScope:(JSObjectionScope)scope named:(NSString *)name;
- (void)bindClass:(Class)aClass toProtocol:(Protocol *)aProtocol;
- (void)bindClass:(Class)aClass toProtocol:(Protocol *)aProtocol named:(NSString*)name;
- (void)bindClass:(Class)aClass toProtocol:(Protocol *)aProtocol inScope:(JSObjectionScope)scope named:(NSString*)name;
- (void)bindClass:(Class)aClass toClass:(Class)toClass;
- (void)bindClass:(Class)aClass toClass:(Class)toClass named:(NSString*)name;
- (void)bindClass:(Class)aClass toClass:(Class)toClass inScope:(JSObjectionScope)scope named:(NSString*)name;
- (void)bindBlock:(id (^)(JSObjectionInjector *context))block toClass:(Class)aClass;
- (void)bindBlock:(id (^)(JSObjectionInjector *context))block toClass:(Class)aClass named:(NSString *)name;
- (void)bindBlock:(id (^)(JSObjectionInjector *context))block toProtocol:(Protocol *)aProtocol;
- (void)bindBlock:(id (^)(JSObjectionInjector *context))block toProtocol:(Protocol *)aProtocol named:(NSString *)name;
- (void)bindBlock:(id (^)(JSObjectionInjector *context))block toClass:(Class)aClass inScope:(JSObjectionScope)scope;
- (void)bindBlock:(id (^)(JSObjectionInjector *context))block toClass:(Class)aClass inScope:(JSObjectionScope)scope named:(NSString *)name;
- (void)bindBlock:(id (^)(JSObjectionInjector *context))block toProtocol:(Protocol *)aProtocol inScope:(JSObjectionScope)scope;
- (void)bindBlock:(id (^)(JSObjectionInjector *context))block toProtocol:(Protocol *)aProtocol inScope:(JSObjectionScope)scope named:(NSString *)name;
- (void)bindClass:(Class)aClass inScope:(JSObjectionScope)scope;
- (void)registerEagerSingleton:(Class)aClass;
- (BOOL)hasBindingForClass:(Class)aClass;
- (BOOL)hasBindingForClass:(Class)aClass withName:(NSString*)name;
- (BOOL)hasBindingForProtocol:(Protocol *)protocol;
- (BOOL)hasBindingForProtocol:(Protocol *)protocol withName:(NSString*)name;
- (void)configure;

可以看出Module支持各种绑定操作：

我们可以将Class和Protocol绑定在一起，通过protocol拿到Class的实例对象，此种方式为我们进行面向接口编程提供了很好的支持。
举个例子，假设现在有个Car类，我们使用Car类实例化出一个对象，使用JSObjection的代码应该是这个样子的：

//CarDao
@protocol CarDao <NSObject>
- (void)fire;  //启动
@end

//Car
@interface Car : NSObject<CarDao>

@end

//绑定
JSObjectionModule *module = [[JSObjectionModule alloc] init];
[module bindClass:[Car class] toProtocol:@protocol(CarDao)];

//获取
id<CarDao> carDao = [[JSObjection defaultInjector] getObject:@protocol(CarDao)];
[carDao fire];

可以将instance和Class/Protocol绑定在一起
可以将实现了JSObjectionProvider接口的对象和Class/Protocol绑定在一起，在该对象中实现接口方法- (id)provide:(JSObjectionInjector *)context arguments:(NSArray *)arguments，在这个方法中实例化你需要的对象。
还可以将block和Class/Protocol绑定在一起，block的返回值就是你需要的实例化对象。
最后，我们也可以从JSObjectionModule派生出子类，重写configure方法，在这个方法中进行绑定操作。

绑定的下一步操作做什么？

在JSObjectionModule中会把你需要绑定的数据封装成JSObjectionEntry对象（这个类还有3个子类，分别是JSObjectionProviderEntry、JSObjectionInjectorEntry、JSObjectionBindingEntry），然后把这个对象作为value，Class/Protocol作为key存放进一个bindings字典容器中。针对绑定的数据类型不通，封装所使用的子类类型也不同，总结就是：
（1）如果绑定的是instance，就会使用JSObjectionBindingEntry进行封装；
（2）如果绑定的是实现了JSObjectionProvider接口的对象，亦或是Class-Protocol，都会使用JSObjectionProviderEntry进行封装；
（3）其他都使用JSObjectionInjectorEntry进行封装。

而JSObjectionInjector中也有一个字典容器变量context，JSObjectionInjector会将Module管理的bindings数据添加到context中，这样，我们后续便可以通过JSObjectionInjector对象获取到最初通过Module绑定的数据。

2.实例对象构建流程

说到对象的构建流程，不得不再把JSObjectionEntry拿出来，在这个类文件中，还有一个同名的JSObjectionEntry协议（接口），如下：

@protocol JSObjectionEntry<NSObject>
  
@property (nonatomic, readonly) JSObjectionScope lifeCycle;  //声明周期
@property (nonatomic, assign) JSObjectionInjector *injector;  //注入者

@required
- (id)extractObject:(NSArray *)arguments;  //根据args参数实例化出对象
+ (id)entryWithEntry:(JSObjectionEntry *)entry;
@optional
-(id)extractObject:(NSArray *)arguments initializer: (SEL)initializer;   //根据args参数实例化出对象

@end

知道这个协议中每个属性及方法的作用对于构建实例对象至关重要。

父类遵守了这套协议，并对这几个方法创建了默认的实现，而派生自JSObjectionEntry的3个子类均对这套协议的方法有着不同的实现，为什么会有不同的实现？因为每个子类绑定的数据类型不同，因此数据类型不同，实例化的方式也不同。

一个一个来看。

（1）JSObjectionBindingEntry

- (id)extractObject:(NSArray *)arguments {
    return _instance;
}

JSObjectionBindingEntry对接口方法的时间很简单，直接把绑定的instance返回就好了。

（2）JSObjectionProviderEntry

- (id)extractObject:(NSArray *)arguments {
    if (self.lifeCycle == JSObjectionScopeNormal || !_storageCache) {
        return [self buildObject:arguments];
    }

    return _storageCache;
}

- (id)buildObject:(NSArray *)arguments {
    id objectUnderConstruction = nil;
    if (_block) {
        objectUnderConstruction = _block(self.injector);
    }
    else {
        objectUnderConstruction = [_provider provide:self.injector arguments:arguments];
    }
    if (self.lifeCycle == JSObjectionScopeSingleton) {
        _storageCache = objectUnderConstruction;
    }
    return objectUnderConstruction;
}

如果你是通过JSObjectionModule的bindBlock方法进行绑定操作，那么就会执行objectUnderConstruction = _block(self.injector);,直接把block中return的数据返回给你。

如果你是通过JSObjectionModule的bindProvider方法进行绑定操作，那么就会执行objectUnderConstruction = [_provider provide:self.injector arguments:arguments];，找到你曾经绑定过的并实现了JSObjectionProvider接口的自定义对象，再调用privide:arguments:方法，这个方法实现中会返回你所实例化的对象。代码示例如下：

@implementation CarProvider
- (id)provide:(JSObjectionInjector *)context arguments:(NSArray *)arguments {
    Car *car = [context getObject:[Car class]];
    return car;
}
@end

（3）JSObjectionInjectorEntry

- (instancetype)extractObject:(NSArray *)arguments {
    return [self extractObject:arguments initializer:nil];
}

- (instancetype) extractObject:(NSArray *)arguments initializer:(SEL)initializer {
    if (self.lifeCycle == JSObjectionScopeNormal || !_storageCache) {
        return [self buildObject:arguments initializer: initializer];
    }
    return _storageCache;
}

- (id)buildObject:(NSArray *)arguments initializer: (SEL) initializer {
    
    id objectUnderConstruction = nil;
    
    if(initializer != nil) {
        objectUnderConstruction = JSObjectionUtils.buildObjectWithInitializer(self.classEntry, initializer, arguments);
    } else if ([self.classEntry respondsToSelector:@selector(objectionInitializer)]) {
        objectUnderConstruction = JSObjectionUtils.buildObjectWithInitializer(self.classEntry, [self initializerForObject], [self argumentsForObject:arguments]);
    } else {
        objectUnderConstruction = [[self.classEntry alloc] init];
    }

    if (self.lifeCycle == JSObjectionScopeSingleton) {
        _storageCache = objectUnderConstruction;
    }
    
    JSObjectionUtils.injectDependenciesIntoProperties(self.injector, self.classEntry, objectUnderConstruction);
    
    return objectUnderConstruction;
}

这个类实现的接口方法是最复杂的，也充分体现了DI和IoC的思想。

从最后一个方法调用中，我们可以看出思路大致如下：
（1）这个方法有两个入参，分别是完整实例化依赖的参数和构造方法。
（2）先判断绑定的类有没有通过注解自定义构造方法，如果有，就会执行JSObjectionUtils.buildObjectWithInitializer(self.classEntry, initializer, arguments);，Class有了，类的构造方法有了，构造方法依赖的参数也有了，有了这些就可以创建出一个完整的实例对象。
（3）如果没有通过注解自定义构造方法，会判断你有没有通过使用objection_initializer_sel注解，这一步的处理逻辑和（2）是相同的。
（4）如果（2）和（3）都没有，就会使用alloc init进行初始化操作。
（5）最后会使用JSObjectionUtils.injectDependenciesIntoProperties(self.injector, self.classEntry, objectUnderConstruction);将对象初始化依赖的属性值注入进去。
（6）如果某个类的属性是另外一个类，就会递归执行这个流程，确保所有属性都是经过初始化的。

更多的实现细节可以查看JSObjectionUtils这个结构体。

3.从容器获取实例

最开始我们提到，JSObjection会收集所有的JSObjectionModule创建出JSObjectionInjector对象，相当于JSObjectionInjector对象保存了我们绑定的数据（并不是所有数据，所以一定要注意使用正确的injector对象获取绑定的数据），所以想要获取IoC容器为什么创建的实例对象，我们也要通过JSObjectionInjector对象来获取，确切说应该是injector对象的这些方法：

- (id)getObject:(id)classOrProtocol;
- (id)getObject:(id)classOrProtocol named:(NSString*)name;
- (id)getObjectWithArgs:(id)classOrProtocol, ... NS_REQUIRES_NIL_TERMINATION;
- (id)getObject:(id)classOrProtocol namedWithArgs:(NSString*)name, ... NS_REQUIRES_NIL_TERMINATION;
- (id)getObject:(id)classOrProtocol arguments:(va_list)argList;
- (id)getObject:(id)classOrProtocol named:(NSString*)name arguments:(va_list)argList;
- (id)getObject:(id)classOrProtocol argumentList:(NSArray *)argumentList;
- (id)getObject:(id)classOrProtocol initializer:(SEL)selector argumentList:(NSArray *)argumentList;
- (id)getObject:(id)classOrProtocol named:(NSString*)name argumentList:(NSArray *)argumentList;
- (id)getObject:(id)classOrProtocol named:(NSString*)name initializer:(SEL)selector argumentList:(NSArray *)argumentList;

虽然方法有点多，但这些方法最后都会统一调用最后一个方法：

- (id)getObject:(id)classOrProtocol named:(NSString*)name initializer:(SEL)selector argumentList:(NSArray *)argumentList {
    @synchronized(self) {
        if (!classOrProtocol) {
            return nil;
        }
        NSString *key = nil;
        BOOL isClass = class_isMetaClass(object_getClass(classOrProtocol));
        
        if (isClass) {
            key = NSStringFromClass(classOrProtocol);
        } else {
            key = [NSString stringWithFormat:@"<%@>", NSStringFromProtocol(classOrProtocol)];
        }
        
        if (name)
        {
            key = [NSString stringWithFormat:@"%@:%@",key,name];
        }
        
        id<JSObjectionEntry> injectorEntry = [_context objectForKey:key];
        injectorEntry.injector = self;
        
        if (!injectorEntry) {
            id<JSObjectionEntry> entry = [_globalContext objectForKey:key];
            if (entry) {
                injectorEntry = [[entry class] entryWithEntry:entry];
                injectorEntry.injector = self;
                [_context setObject:injectorEntry forKey:key];
            } else if(isClass) {
                injectorEntry = [JSObjectionInjectorEntry entryWithClass:classOrProtocol scope:JSObjectionScopeNormal];
                injectorEntry.injector = self;
                [_context setObject:injectorEntry forKey:key];
            }
        }
        
        if (classOrProtocol && injectorEntry) {
            if ([injectorEntry respondsToSelector:@selector(extractObject:initializer:)]) {
                return [injectorEntry extractObject:argumentList initializer:selector];
            }
            return [injectorEntry extractObject:argumentList];
        }
        
        return nil;
    }
    
    return nil;
}

在最后一个方法中，获取实例变量的流程是这样的：
（1）根据Class或者Protocol，还有别名生成key。
（2）拿着key先到context中去取数据，取到的数据是JSObjectionEntry类型的数据（因为这是一个父类），并且JSObjectionEntry实现了JSObjectionEntry协议，因此取到的数据会用id<JSObjectionEntry>这种匿名方式去接收。
（3）如果数据不存在，就到globalContext中去取（相当于二级缓存），如果取到对象，就放入context（一级缓存）中，如果没取到对象，就创建一个JSObjectionInjectorEntry对象并放入context中。
（4）如果经过（2）和（3）我们获取到了一个id<JSObjectionEntry>匿名对象，就会调用这个匿名对象的extractObject:initializer:或extractObject:方法，这两个方法的具体实现在上面我们已经讲过了，在这两个方法中会创建实例对象，最终会将这个实例对象返回，我们通过IoC容器拿到的，就是这个实例对象。
（5）异常情况都会返回nil。

流程图中间的位置有一条蓝色虚线连接左右两部分，对应着上面所讲述的流程。

四、`JSObjection`的使用

（1）构造方法注入

定义接口：

@protocol CarDao <NSObject>

@property(nonatomic, copy) NSString *color; //汽车的颜色

- (void)fire; //启动

@end

定义接口实现类：

@interface Car : NSObject<CarDao>

@end

@implementation Car

//构造方法注入
- (instancetype)initWithColor:(NSString *)color {
    if (self = [super init]) {
        self.color = color;
    }
    return self;
}

//构造方法注入
objection_initializer(initWithColor:)

@synthesize color = _color;

- (void)fire {
    NSLog(@"我开着我%@的小汽车走了.", _color);
}

@end

绑定Class-Protocol：

JSObjectionModule *module = [[JSObjectionModule alloc] init];
[module bindClass:[Car class] toProtocol:@protocol(CarDao)];
JSObjectionInjector *injector = [JSObjection createInjector:module];
[JSObjection setDefaultInjector:injector];

获取匿名对象（也就是实现了CarDao接口的Car实例对象）：

id<CarDao> carDao = [[JSObjection defaultInjector] getObjectWithArgs:@protocol(CarDao), @"黑色", nil];
[carDao fire];

（2）属性注入

CarDao代码不变，对Car进行一些改造：

@implementation Car

- (instancetype)init {
    if (self = [super init]) {
        _color = @"蓝色";
    }
    
    return self;
}

@synthesize color = _color;

- (void)fire {
    NSLog(@"我开着我%@的小汽车走了.", _color);
}

@end

PersonDao：

@protocol PersonDao <NSObject>

@property(nonatomic, strong) id<CarDao> car;        //汽车

@optional
- (void)info;   //个人信息

@end

Person：

@interface Person : NSObject<PersonDao>

@end


@implementation Person

//属性注入
objection_requires(@"car")

@synthesize car = _car;

- (void)info {
    NSLog(@"-------------------------");
    [_car fire];
    NSLog(@"-------------------------");
}

@end

绑定及获取：

- (void)viewDidLoad {
    [super viewDidLoad];
    
    JSObjectionModule *module = [[JSObjectionModule alloc] init];
    [module bindClass:[Person class] toProtocol:@protocol(PersonDao)];
    [module bindClass:[Car class] toProtocol:@protocol(CarDao)];

    JSObjectionInjector *injector = [JSObjection createInjector:module];
    [JSObjection setDefaultInjector:injector];
    
    //构造方法注入
    id<PersonDao> personDao = [[JSObjection defaultInjector] getObject:@protocol(PersonDao)];
    [personDao info];
}

完结。

对Typhoon的补充

对于文章中提到的另一个IoC容器Typhoon，这里做一个简单的原理分析吧，Typhoon提供的功能非常接近于Java的Spring框架，包括AOP & DI & IoC。

Typhoon在info.plist文件中维护了一个表，表名叫TyphoonInitialAssemblies，如下：

WX20180823-174024.png

每个item中的字符串数据都可以经过反射生成项目中的类。

这些类的名称是以Assembly为结尾的，意为部件。

Assembly管理着众多的Definition，Definition意为定义。

我们创建的类都以Assembly为结尾，表示部件(组件),在部件类中，我们会使用TyphoonDefinition中去关联要注入的Controller/view/other objc，并指定这些对象初始化所需要的初始化构造方法/属性注入/方法注入等，所以我们可以知道Assembly和Definition是一对多关系。

在程序启动的时候首先会执行main函数：

int main(int argc, char *argv[])
{
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([PFAppDelegate class]));
    }
}

UIApplication会设置AppDelegate对象，设置会调用setAppDelegate:方法，于是Typhoon就hook住了这个方法，在替换的方法实现中，会读取当前bundle的info.plist文件，获取到TyphoonInitialAssemblies配置的内容，因为这个配置项是个数组，里面存储的是Class对应的字符串，所以获取到这些类的字符串之后就会通过反射获取到类，再将这些类放入到数组中，如果数组count>0就会通过这个数组实例化TyphoonComponentFactory对象，这个工厂对象有个私有属性_registry，里面保存的就是我们通过TyphoonDefinition注入的模块。

获取到他们的Definition之后，会将其添加到TyphoonComponentFactory（组件工厂）中，等到我们取得时候，也是到这个组件工厂中去取。

所以使用Typhoon的时候就要维护好你写的代码，因为Typhoon hook住了你当前应用程序的入口，如果在这个过程中，因为你写的代码造成了程序异常，程序可能就会无法正常启动。

敬业的程序猿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Objection源码解析

一、简介Objection是一个iOS中轻量级的对DI及IoC的实现，不知道DI及IoC的请移步至iOS组件通信方案，Objection只有Object-C版本，没有Swift版本，如果你想在Swift中使用这种容器框架，可以了解下Typhoon，二者对于DI的实现方式不同，原理也不同，本篇文章主要分析Objection。它的优点有哪些呢？支持我们进行面向接口编程，有利于项目解耦（组件...
复制链接

扫一扫