Tigase8.0 引用了IoC(控制反转)和DI(依赖注入) 等技术手段，来对对象的创建和控制。不懂的百度下就知道了，Spring完美的实现IOC ，贴一段解释：
通俗地说：控制反转IoC(Inversion of Control)是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方，比如转移交给了IoC容器，它就是一个专门用来创建对象的工厂，你要什么对象，它就给你什么对象，有了 IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，通过IoC容器来建立它们之间的关系。
DI(依赖注入)其实就是IOC的另外一种说法，DI是由Martin Fowler 在2004年初的一篇论文中首次提出的。他总结：控制的什么被反转了？就是：获得依赖对象的方式反转了。
在Tigase8 中，IOC容器由 Kernel 类实现，Kernel是充当容器管理所有类的依赖对象的注入。
类似Spring 的bean ,在Tigase中，只要是类标有 @Bean(name = "xxx", parent = Kernel.class, active = true) ，标有Bean注解的类，表明该类的对象创建交由容器负责生成
类属性字段上标有 @Inject(bean = "kernel") 注解时，表明该字段交由容器来赋值
Tigase8 中大量使用JAVA8 Function及Stream编程，需要补充基础的同学，可以 https://github.com/CarpenterLee/JavaLambdaInternals 进行学习！
下面开始进行代码的粗略讲解，其实 由7到8过渡，核心的架构思想是没有多大变化的，8中只是加入对象的创建管理手段而已，也可以看以前的文章来了解每个组件之间的逻辑关系
入口类 public final class XMPPServer
public static void start(String[] args) {
...
bootstrap = new Bootstrap();
bootstrap.init(args); //加载配置文件等参数
bootstrap.start(); //启动系统所有的工作组件进行提供服务
}
启动包装类 public class Bootstrap
public void start() {
//跳过些次要代码
......
//类加载工具类
classUtilBean = (ClassUtilBean) Class.forName("tigase.util.reflection.ClassUtilBean").newInstance();
//通过查找classpath下的jar,或dir，并且跳过一些过滤的包路径，加载所有的类的Class对象，为后面程序能通过@Bean注解能查找到所有需要容器管理的类
classUtilBean.initialize(ClassUtilBean.getPackagesToSkip(null));
// 注册默认类型转换器和属性bean配置器
kernel.registerBean(DefaultTypesConverter.class).exportable().exec();
// DSLBeanConfigurator 注册到Kernel的beanInstances中，DSLBeanConfiguratorWithBackwardCompatibility 向下兼容的配置文件管理类，对于Tigase来说非常重要，也就是各种Bean加载的入口
kernel.registerBean(DSLBeanConfiguratorWithBackwardCompatibility.class).exportable().exec();
DSLBeanConfigurator configurator = kernel.getInstance(DSLBeanConfigurator.class);
configurator.setConfigHolder(config);
// 加载所有@Bean(name = "message-router", parent = Kernel.class, active = true) Bean中 parent = Kernel.class 的类，并进行注册到Kernel容器中，如下图所示：
configurator.registerBeans(null, null, config.getProperties());
// 启动路由组件的服务
MessageRouter mr = kernel.getInstance("message-router");
mr.start();
}
如下图所示，查找标有@Bean注解，并且parent=Kernel.class 的Bean集合的Class，并且进行实例化，注册到Kernel中
一、重点来说下 AbstractBeanConfigurator.registerBeans(null, null, config.getProperties()); 加载查找标有@Bean注解，并且parent=Kernel.class 的Bean，注册到Kernel中
public void registerBeans(BeanConfig beanConfig, Object bean, Map<String, Object> values) {
//查找标有@Bean注解，并且parent=Kernel.class 的Bean集合
final Map<String, Class<?>> beansFromAnnotations = getBeanClassesFromAnnotations(kernel, beanConfig == null
? Kernel.class
: beanConfig.getClazz());
....
//遍历所查找到的Bean集合，进行注册到Kernel中
beansFromAnnotations.forEach((name, cls) -> {
kernel.registerBean(cls)
.setSource(BeanConfig.Source.annotation)
.registeredBy(beanConfig)
.execWithoutInject();
....
}
查找@Bean中parent属性为参数类型的Bean
public static Map<String, Class<?>> getBeanClassesFromAnnotations(Kernel kernel, Class<?> requiredClass) {
//从classpath加载到的Class集合中
Set<Class<?>> classes = ClassUtilBean.getInstance().getAllClasses();
//遍历这些Class查找出标有@Bean注解，并且parent属性为requiredClass类型的bean Class
List<Class<?>> toRegister = registerBeansForBeanOfClassGetBeansToRegister(kernel, requiredClass, classes);
//转换下返回类型
Map<String, Class<?>> result = new HashMap<>();
for (Class<?> cls : toRegister) {
Bean annotation = cls.getAnnotation(Bean.class);
result.put(annotation.name(), cls);
}
return result;
}
二、启动路由组件的服务，
// 启动路由组件的服务
MessageRouter mr = kernel.getInstance("message-router");
mr.start();
在执行getInstance（）的时候，对还没初始化的对象进行初始化，进行依赖注入等操作
在首次获取Bean实例对象的时候，针对bean对象进行一些配置操作，和依赖注入操作，此后，bean实例才是一个完整的对象，其实和Spring中bean的获取原理是差不多的，不过这里要单纯很多，简单些
protected void initBean(BeanConfig tmpBC, Set<BeanConfig> createdBeansConfig, int deep){
....
//构建延迟依赖注入的本地线程队列
DelayedDependencyInjectionQueue queue = beanConfig.getKernel().beginDependencyDelayedInjection();
//针对于初始化的Bean判断是否为系统所默认的配置管理类，如果不是配置管理类本身，则其它类需要调用配置管理类的configure()方法进行配置项处理，如标有@ConfigField的字段
if (beanConfig.getKernel().isBeanClassRegistered(BeanConfigurator.DEFAULT_CONFIGURATOR_NAME) &&
!beanConfig.getBeanName().equals(BeanConfigurator.DEFAULT_CONFIGURATOR_NAME)) {
beanConfigurator = beanConfig.getKernel().getInstance(BeanConfigurator.DEFAULT_CONFIGURATOR_NAME);
} else {
beanConfigurator = null;
}
....
//如果不是默认配置类，则需要进行配置类的configure方法进行处理
if (beanConfigurator != null) {
//此方法会加载@Bean(name = "message-router", parent = beanConfig.clazz.class, active = true),加载@Bean注解中parent为参数beanConfig.clazz类型的Bean，并注册到Kernel中，下面会重点分解：1
beanConfigurator.configure(beanConfig, bean);
} else {
//如果是默认配置类本身，则进行配置类对象的创建和注册到kernel中
AbstractBeanConfigurator.registerBeansForBeanOfClass(beanConfig.getKernel(), bean.getClass());
}
//这个是线程私有队列，这里进行清理工作
beanConfig.getKernel().finishDependecyDelayedInjection(queue);
//这里重点，针对@Bean中所有@Inject注解的字段，进行依赖搜索和依赖注入操作
for (final Dependency dep : beanConfig.getFieldDependencies().values()) {
beanConfig.getKernel().injectDependencies(bean, dep, createdBeansConfig, deep, false);
}
//如果实现Initializable 接口，则触发.initialize()函数的调用
// there is no need to wait to initialize parent beans, it there any?
if (bean instanceof Initializable && beanConfig.getState() != State.initialized) {
((Initializable) bean).initialize();
}
}
1、重点谈下 beanConfigurator.configure(beanConfig, bean);
public void configure(BeanConfig beanConfig, Object bean) throws KernelException {
try {
grabDefaultConfig(beanConfig, bean);
Map<String, Object> ccc = getConfiguration(beanConfig);
configure(beanConfig, bean, ccc);//调用父类的配置方法
} catch (Exception e) {
throw new KernelException("Cannot inject configuration to bean " + beanConfig.getBeanName(), e);
}
}
重点进入父类的configure（）方法，查找出@bean注册中parent=beanConfig.clazz类型的Class,进行注册到Kernel容器中
public void AbstractBeanConfigurator.configure(BeanConfig beanConfig, Object bean, Map<String, Object> values) {
........
//查找@Bean中parent属性为参数beanConfig.clazz的类，并加载到Kernel容器中
registerBeans(beanConfig, bean, values);
.........
}
根据查找到的Bean Class，进行注册，同时涉及到依赖到别的Bean，则判断当前本地线程中是否延迟注入队列，有值，则放到队列中，运行完本操作后，在.finishDependecyDelayedInjection(queue);中完成注入
public void registerBeans(BeanConfig beanConfig, Object bean, Map<String, Object> values) {
if (beanConfig != null && Kernel.class.isAssignableFrom(beanConfig.getClazz())) {
return;
}
//获得核心的容器管理类
Kernel kernel = beanConfig == null ? this.getKernel() : beanConfig.getKernel();
//找出beanConfig.clazz已经注册的Bean,用于取消注册
Set<String> toUnregister = new ArrayList<>(kernel.getDependencyManager().getBeanConfigs()).stream()
.filter(bc -> bc.getSource() == BeanConfig.Source.configuration)
.filter(bc -> beanConfig == null || bc.getRegisteredBy().contains(beanConfig))
.map(bc -> bc.getBeanName())
.collect(Collectors.toSet());
//遍历classpath中过滤出来的全部Class，查找出标有@Bean注解，并且parent属性为Kernel.class或beanConfig.getClazz()类型的bean Class
final Map<String, Class<?>> beansFromAnnotations = getBeanClassesFromAnnotations(kernel, beanConfig == null
? Kernel.class
: beanConfig.getClazz());
//查找该配置参数中为BeanDefinition的配置项
final Map<String, BeanDefinition> beanDefinitionsFromConfig =
values == null ? new HashMap<>() : mergeWithBeansPropertyValue(getBeanDefinitions(values), values);
///遍历查找出来的beanConfig.clazz类型子Bean集合，依次进行注册到Kernel容器中
beansFromAnnotations.forEach((name, cls) -> {
if (beanDefinitionsFromConfig != null) {
BeanDefinition definition = beanDefinitionsFromConfig.get(name);
if (definition != null) {
return;
}
}
if (isBeanClassRegisteredInParentKernel(kernel.getParent(), name, cls)) {
return;
}
BeanConfig bc = kernel.getDependencyManager().getBeanConfig(name);
if (bc != null && bc.getSource() == BeanConfig.Source.annotation && bc.getClazz().equals(cls)) {
return;
}
if (beanConfig != null && beanConfig.getState() == BeanConfig.State.initialized) {
kernel.registerBean(cls).setSource(BeanConfig.Source.annotation).registeredBy(beanConfig).exec();
} else {
//后面要重点讲解下注册，注册到kernel容器中。当注册A对象时，可能会依赖到B对象，所以注册里有使用到本地线程延迟注册队列
kernel.registerBean(cls)
.setSource(BeanConfig.Source.annotation)
.registeredBy(beanConfig)
.execWithoutInject();
}
bc = kernel.getDependencyManager().getBeanConfig(name);
if (bc != null && bc.getState() == BeanConfig.State.inactive && hasDirectConfiguration(bc)) {
log.log(Level.CONFIG, "bean " + bc.getBeanName() + " is disabled but configuration is specified");
}
});
//根据参数中为BeanDefinition的配置项，查看该Bean是否已经注册，没有则进行注册
for (BeanDefinition cfg : beanDefinitionsFromConfig.values()) {
try {
Class<?> clazz = cfg.getClazzName() == null
? beansFromAnnotations.get(cfg.getBeanName())
: ModulesManagerImpl.getInstance().forName(cfg.getClazzName());
BeanConfig oldBc = kernel.getDependencyManager().getBeanConfig(cfg.getBeanName());
if (clazz == null) {
if (bean != null && bean instanceof RegistrarBeanWithDefaultBeanClass) {
clazz = ((RegistrarBeanWithDefaultBeanClass) bean).getDefaultBeanClass();
} else if (oldBc != null) {
clazz = oldBc.getClazz();
}
if (clazz == null) {
log.log(Level.WARNING, "unknown class {0} for bean {1}, skipping registration of a bean",
new Object[]{cfg.getClazzName(), cfg.getBeanName()});
continue;
}
}
if (!tigase.util.reflection.ClassUtilBean.getInstance().getAllClasses().contains(clazz)) {
continue;
}
toUnregister.remove(cfg.getBeanName());
if (oldBc != null && oldBc.getClazz().equals(clazz) &&
(oldBc.isExportable() || cfg.isExportable() == oldBc.isExportable())) {
kernel.setBeanActive(cfg.getBeanName(), cfg.isActive());
} else {
Bean ba = clazz.getAnnotation(Bean.class);
BeanConfigBuilder cfgBuilder = kernel.registerBean(cfg.getBeanName()).asClass(clazz);
cfgBuilder.setActive(cfg.isActive()).setSource(BeanConfig.Source.configuration);
if (cfg.isExportable()) {
cfgBuilder.exportable();
}
if (ba != null) {
if (ba.exportable()) {
cfgBuilder.exportable();
}
}
cfgBuilder.registeredBy(beanConfig);
if (beanConfig != null && beanConfig.getState() == BeanConfig.State.initialized) {
cfgBuilder.exec();
} else {
cfgBuilder.execWithoutInject();
}
}
} catch (ClassNotFoundException ex) {
log.log(Level.FINER,
"could not register bean '" + cfg.getBeanName() + "' as class '" + cfg.getClazzName() +
"' is not available", ex);
}
}
toUnregister.forEach(beanName -> kernel.unregister(beanName));
}
重点讲解下注册，当执行注册但还没依赖注入的函数。
public BeanConfig BeanConfigBuilder.execWithoutInject() {
if (beanConfig == null) {
log.warning("Bean " + clazz +
" cannot be registered, because Kernel cannot create configuration for this bean.");
kernel.currentlyUsedConfigBuilder = null;
return null;
}
//执行bean的注册
beanConfig = kernel.registerBean(beanConfig, factoryBeanConfig, beanInstance);
return beanConfig;
}
注册bean实例到Kernel.beanInstances中，bean中所依赖inject的类型，注册到dependencyManager.beanConfigs中，beanConfig通过state来区分，是否为初始化完成的实例
protected BeanConfig Kernel.registerBean(BeanConfig beanConfig, BeanConfig factoryBeanConfig, Object beanInstance) {
BeanConfig parent = null;
if (beanConfig.getSource() == BeanConfig.Source.annotation && !beanConfig.getRegisteredBy().isEmpty()) {
BeanConfig bc = dependencyManager.getBeanConfig(beanConfig.getBeanName());
parent = beanConfig.getRegisteredBy().iterator().next();
if (bc != null && bc.getClazz().equals(beanConfig.getClazz())) {
bc.addRegisteredBy(parent);
parent.addRegisteredBean(bc);
currentlyUsedConfigBuilder = null;
return bc;
}
}
if (factoryBeanConfig != null) {
factoryBeanConfig.setPinned(beanConfig.isPinned());
factoryBeanConfig.setState(beanConfig.getState());
unregisterInt(factoryBeanConfig.getBeanName());
dependencyManager.register(factoryBeanConfig);
}
BeanConfig oldBeanConfig = dependencyManager.getBeanConfig(beanConfig.getBeanName());
Collection<Dependency> oldDeps =
oldBeanConfig == null ? null : dependencyManager.getDependenciesTo(oldBeanConfig);
unregisterInt(beanConfig.getBeanName());
//注册进依赖管理类
dependencyManager.register(beanConfig);
if (parent != null) {
parent.addRegisteredBean(beanConfig);
}
//当实例对象不为空，则更新bean的状态为initialized
if (beanInstance != null) {
putBeanInstance(beanConfig, beanInstance);
beanConfig.setState(State.initialized);
}
//查找出本bean可以注入的被依赖集合，简单地说是B 对象内有个依赖注入的A属性，现在beanConfig为A实现类，此时这里就可以查找出B对象这个依赖项包装类Dependency
Collection<Dependency> deps = dependencyManager.getDependenciesTo(beanConfig);
if (oldDeps != null) {
deps.addAll(oldDeps.stream().filter(od -> {
Field f = od.getField();
return !deps.stream().anyMatch(nd -> nd.getField().equals(f));
}).collect(Collectors.toSet()));
}
currentlyUsedConfigBuilder = null;
//如果此函数在所在的本地线程内有延迟注入队列，则加入队列，在finishDependecyDelayedInjection(queue);进行给依赖本beanConfig类型的对象，进行依赖注入
if (!queueForDelayedDependencyInjection(deps)) {
//当本地线程内无延迟注入队列则为依赖本beanConfig类的对象立即执行依赖注入
injectDependencies(deps);
}
return beanConfig;
}
前面，我们在 initBean(BeanConfig tmpBC, Set<BeanConfig> createdBeansConfig, int deep) 中有看到 beanConfig.getKernel().finishDependecyDelayedInjection(queue);关于赋值就是在这里进行
private boolean queueForDelayedDependencyInjection(Collection<Dependency> deps) {
//本地线程队列存在的时候，才会放到队列里去，后面再进行注入
DelayedDependencyInjectionQueue queue = DELAYED_DEPENDENCY_INJECTION.get();
if (queue == null) {
return false;
}
if (deps.isEmpty()) {
return true;
}
queue.offer(new DelayedDependenciesInjection(deps));
return true;
}
2.举个例子进一步说明下，如MessageRouter中依赖注入componentsAll字段，
@Inject private Set<ServerComponent> componentsAll;
当调用initBean时，程序针对 componentsAll字段进行依赖注入，当xxx字段有提供setXxx() 的函数时，系统会自动调用该函数。如MessageRouter中提供 setComponentsAll(Set<ServerComponent> components) 函数，所以，当注入componentsAll字段时，会自动调用setComponentsAll函数
例如在 MessageRouter 需要注入 componentsAll 组件集合对象，就是在getInstance()时触发的操作
@Bean(name = "message-router", parent = Kernel.class, active = true)
public class MessageRouter ..{
@Inject
private Set<ServerComponent> componentsAll;
public void setComponentsAll(Set<ServerComponent> components) {
if (components == null) {
return;
}
HashSet<ServerComponent> removeComponents = new HashSet<>(this.components.values());
removeComponents.removeAll(components);
for (ServerComponent comp : removeComponents) {
if (comp instanceof ComponentRegistrator) {
removeRegistrator((ComponentRegistrator) comp);
} else if (comp instanceof MessageReceiver) {
removeRouter((MessageReceiver) comp);
} else {
removeComponent(comp);
}
if (comp instanceof ConnectionManager) {
connectionManagerNames.remove(comp.getName());
}
comp.release();
}
HashSet<ServerComponent> newComponents = new HashSet<>(components);
newComponents.removeAll(this.components.values());
//这里加载到的组件进行相互注册，通知，和7版本的逻辑是一样的，可以去看以前的文章
for (ServerComponent comp : newComponents) {
try {
if (comp instanceof MessageReceiver) {
MessageReceiver mr = (MessageReceiver) comp;
mr.setParent(this);
mr.start();
}
if (comp instanceof ConnectionManager) {
connectionManagerNames.add(comp.getName());
}
if (comp instanceof ComponentRegistrator) {
addRegistrator((ComponentRegistrator) comp);
} else if (comp instanceof MessageReceiver) {
addRouter((MessageReceiver) comp);
} else {
addComponent(comp);
}
} catch (ConfigurationException ex) {
// TODO - most likely this will no longer happen as configuration will not be done in this method
log.log(Level.WARNING, "component " + comp.getName() + " was not configured properly", ex);
}
}
}
}
三、最终调用 MessageRouter.start() 启动路由组件进行，路由功能，和7版本的原理是一样，这里就不再一一说明，可以找回以前的文章看
到这里启动篇就完成了，Tigase8，看起来代码结构改动大，但是其实也没有多大的变化，核心没有变，变是的包装的架子，所以只要认真地看问题不大，在看源码的同学，建议在调试的时候，再来看这个文章，这样帮助会大些，可以尽可能快地理解Tigase的原理。
如有不对的地方，请提出来，我进行改进！
