应用上
{
[BHContext shareInstance].application = application;
[BHContext shareInstance].launchOptions = launchOptions;
[BHContext shareInstance].moduleConfigName = @"BeeHive.bundle/BeeHive";//可选，默认为BeeHive.bundle/BeeHive.plist
[BHContext shareInstance].serviceConfigName = @"BeeHive.bundle/BHService";
[BHContext shareInstance].lazy_moduleConfigName = @"BeeHive.bundle/BeeHive_lazy";
[BHContext shareInstance].lazy_serviceConfigName = @"BeeHive.bundle/BHService_lazy";
[BeeHive shareInstance].enableException = NO;
// 上面配置 有关的参数： module 和service ，以及有关的参数，
// enableException 由于增加了动态规则的寻找， 所以，这个设置为NO取消掉
[[BeeHive shareInstance] setContext:[BHContext shareInstance]];
// 设置对应的内容， 这个是对应的入口
[super application:application didFinishLaunchingWithOptions:launchOptions];
}
BHSelectorByEvent <事件key: 方法>
BHModulesByEvent <事件key:modules<NSArray>> 这就是通过一个这样的时间有多少个模块
modulesByName; // 存储模块对象：通过名字来获取模块
servicesByName; // 存储服务对象 ： 目前是存储用去作为单例的
@interface BHModuleManager()
@property(nonatomic, strong) NSMutableArray *BHModuleDynamicClasses; // 没有使用到的
@property(nonatomic, strong) NSMutableArray<NSDictionary *> *BHModuleInfos; // 所有的modules信息
@property(nonatomic, strong) NSMutableArray *BHModules; // 所有的Modules
@property(nonatomic, strong) NSMutableDictionary<NSNumber *, NSMutableArray<id<BHModuleProtocol>> *> *BHModulesByEvent; // evenetKey:Modules
@property(nonatomic, strong) NSMutableDictionary<NSNumber *, NSString *> *BHSelectorByEvent; // eventKey:selector
@end
《1》 BeeHive 动态连接注册
将定义在data字段里面的字符串来获取出来，然后注册模块和服务
每个都要进行动态注册： 这个过程必然会比较慢
NSArray<NSString *>* BHReadConfiguration(char *sectionName,const struct mach_header *mhp);
static void dyld_callback(const struct mach_header *mhp, intptr_t vmaddr_slide)
{
// 读取 模块的数据， 然后进行注册
NSArray *mods = BHReadConfiguration(BeehiveModSectName, mhp); // 读取mod的配置内容
for (NSString *modName in mods) {
Class cls;
if (modName) {
cls = NSClassFromString(modName);
if (cls) {
[[BHModuleManager sharedManager] registerDynamicModule:cls]; // 注册动态的mod
}
}
}
//读取服务数据，进行注册
NSArray<NSString *> *services = BHReadConfiguration(BeehiveServiceSectName,mhp); // 读取动态的service的内容，动态的方式加载，动态加载的时候就处理了
for (NSString *map in services) {
NSData *jsonData = [map dataUsingEncoding:NSUTF8StringEncoding];
NSError *error = nil;
id json = [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:&error];
if (!error) {
if ([json isKindOfClass:[NSDictionary class]] && [json allKeys].count) {
NSString *protocol = [json allKeys][0];
NSString *clsName = [json allValues][0];
if (protocol && clsName) {
// 注册service
[[BHServiceManager sharedManager] registerService:NSProtocolFromString(protocol) implClass:NSClassFromString(clsName)];
}
}
}
}
}
__attribute__((constructor)) // 构建的时候就启动这个方法
void initProphet() {
_dyld_register_func_for_add_image(dyld_callback); // 注册了动态链接
}
// 读取数据段的数据方法
NSArray<NSString *>* BHReadConfiguration(char *sectionName,const struct mach_header *mhp)
{
NSMutableArray *configs = [NSMutableArray array];
unsigned long size = 0;
#ifndef __LP64__
uintptr_t *memory = (uintptr_t*)getsectiondata(mhp, SEG_DATA, sectionName, &size);
#else
const struct mach_header_64 *mhp64 = (const struct mach_header_64 *)mhp;
uintptr_t *memory = (uintptr_t*)getsectiondata(mhp64, SEG_DATA, sectionName, &size);
#endif
unsigned long counter = size/sizeof(void*);
for(int idx = 0; idx < counter; ++idx){
char *string = (char*)memory[idx];
NSString *str = [NSString stringWithUTF8String:string];
if(!str)continue;
BHLog(@"config = %@", str);
if(str) [configs addObject:str];
}
return configs;
}
BeeHive 静态注册
性能上面： 总体加载一起注册（相对快点）
BeeHive 静态注册过程
《3》BeeHive 代码动态注册
直接调用动态注册的方法
《4》BeeHive 懒加静态载注册
也是通过plist文件， 文件进行注册（目前是启动8s之后加载 这个信息、或者在使用到的时候再注册）
《5》 根据制定规则注册服务 （懒加载动态注册）【当然，模块也是可以处理的】
在上面没有获取到服务的时候， 根据规则来做最后的查看有没有
获取服务
- (id)createService:(Protocol *)service withServiceName:(NSString *)serviceName shouldCache:(BOOL)shouldCache {
if (!serviceName.length) {
serviceName = NSStringFromProtocol(service);
}
id implInstance = nil;
if (![self checkValidService:service]) { // 可以忽略
if (self.enableException) {
@throw [NSException exceptionWithName:NSInternalInconsistencyException reason:[NSString stringWithFormat:@"%@ protocol does not been registed", NSStringFromProtocol(service)] userInfo:nil];
}
}
//0) 判断缓存里面这个实现 （缓存的单例）
NSString *serviceStr = serviceName;
if (shouldCache) {
id protocolImpl = [[BHContext shareInstance] getServiceInstanceFromServiceName:serviceStr];
if (protocolImpl) {
return protocolImpl;
}
}
// 1)是否已经注册过
Class implClass = [self serviceImplClass:service]; =
{
// 2) 这个服务类是否存在
if (!implClass) {
// 2.1） 静态懒加载
implClass = [[BHLazyManager sharedManager] getIMPWithService:service serviceName:serviceName]; //
if (!implClass) {
// 2.2） 查看服务的模块是否存在，如果没有先注册模块（因为很多时候都是在模块里面注册服务的）
Class moduleClass = [[BHModuleManager sharedManager] findDyanmicModuleWithServiceName:serviceStr];
if (moduleClass) {
BOOL hasModuleRegister = [[BHModuleManager sharedManager] hasRegisterClass:moduleClass];
if (!hasModuleRegister) {
[[BHModuleManager sharedManager] registerDynamicModule:moduleClass shouldTriggerInitEvent:YES];
}
}
// 2.3) 判断服务是否已经注册了，没有就注册服务
implClass = [self serviceImplClass:service];
if (!implClass) {
implClass = [self findDyanmicIMPWithServiceName:serviceStr];
if (implClass) {
[self registerService:service implClass:implClass];
}
}
}
}
}
// 3) 获取对应的服务实现对象
// 3.1) 判断是否是单例以及是否实现了单例， 单例对象精心了缓存
if ([[implClass class] respondsToSelector:@selector(singleton)]) {
if ([[implClass class] singleton]) {
if ([[implClass class] respondsToSelector:@selector(shareInstance)])
implInstance = [[implClass class] shareInstance];
else
implInstance = [[implClass alloc] init];
if (shouldCache) {
[[BHContext shareInstance] addServiceWithImplInstance:implInstance serviceName:serviceStr];
return implInstance;
} else {
return implInstance;
}
}
}
// 3.2) 直接创建对象
return [[implClass alloc] init];
}
PS:
1）BeeHive基于protocol进行注册使用
2）使用了控制反转的思想来创建对象
3）加载plist信息， 通过反射获取对应类以及创建对象。
4）BHRouter 路由，很多都有路由，感觉这个路由太过于繁琐。
[[self class] shareInstance].serviceName和[BHContext shareInstance].serviceName 是有区别的, 编译器编译会给前面的报错
变成思想
IoC 和DI
什么是AOP
IOC、DI和AOP 几个概念的理解
AOP 核心关注点、横切关注点
spring的框架思想和方式： 控制反转 、依赖注入 （DI）及面向切面编程 (AOP) 。
https://www.jianshu.com/p/2efb2d1cbbc8
反射机制： 通过类对象来创建对象， 而不是直接创建对象
Java 反射是可以让我们在运行时获取类的方法、属性、父类、接口等类的内部信息的机制。也就是说，反射本质上是一个“反着来”的过程。我们通过new创建一个类的实例时，实际上是由Java虚拟机根据这个类的Class对象在运行时构建出来的，而反射是通过一个类的Class对象来获取它的定义信息，从而我们可以访问到它的属性、方法，知道这个类的父类、实现了哪些接口等信息。
网友评论