Jetty - Container源码分析
1. 描述
Container提供管理bean的能力。html
基于Jetty-9.4.8.v20171121。java
1.1 API
public interface Container
{
// 增长一个bean，若是bean是一个Container.Listener则隐含调用addEventListener(Container.Listener)方法
// Container.Listener只关心两个事件：（1）增长bean（2）删除bean
public boolean addBean(Object o);
// 返回该Container里面全部的bean
public Collection<Object> getBeans();
// 返回指定类型（包括子类）的bean
public <T> Collection<T> getBeans(Class<T> clazz);
// 返回指定类型（包括子类）的第一个bean，若是不存在则返回null
public <T> T getBean(Class<T> clazz);
// 删除指定的bean，若是bean是一个Container.Listener，隐含调用removeEventListener(Container.Listener)
public boolean removeBean(Object o);
// 增长一个Listener
public void addEventListener(Listener listener);
// 删除一个Listener
public void removeEventListener(Listener listener);
// 未托管一个bean（必须已经存在在Container里面），因此该bean不该该启动，中止或销毁
void unmanage(Object bean);
// 托管一个bean（必须已经存在在Container里面），因此该bean已启动，已中止或销毁
void manage(Object bean);
// 检测该Container是否托管一个bean
boolean isManaged(Object bean);
// 增长一个bean，而且明确是否托管（便是否管理该bean的生命周期）
// 若是已经增长返回true，若是已经存在返回false
boolean addBean(Object o, boolean managed);
// Container事件的监听器
// 若是一个增长的bean实现该接口将会收到该Container的事件
public interface Listener
{
void beanAdded(Container parent,Object child);
void beanRemoved(Container parent,Object child);
}
/**
* Inherited Listener.
* If an added bean implements this interface, then it will
* be added to all contained beans that are themselves Containers
* 若是增长的bean实现该接口，则将该bean增长到当前Container里面全部bean类型为Container里面。
*/
public interface InheritedListener extends Listener
{
}
/**
* @param clazz the class of the beans
* @return the list of beans of the given class from the entire managed hierarchy
* @param <T> the Bean type
*/
public <T> Collection<T> getContainedBeans(Class<T> clazz);
}
从API能够看出Container主要维护bean而且监听bean的增长和删除事件。ide
1.2 类图
从类图能够看出，Container与LifeCycle接口很相似，都是不少组件的基本特征，其默认实现是ContainerLifeCycle。源码分析
2. ContainerLifeCycle
1.2类图能够看出ContainerLifeCycle不只是Container的默认实现，并且也是不少组件（Connector，Handler等）默认实现的父类。this
2.1 类图
ContainerLifeCycle天然要实现Container接口； debug
ContainerLifeCycle继承AbstractLifeCycle，而AbstractLifeCycle里面实现了LifeCycle的模板启停方法start和stop；rest
继承AbstractLifeCycle的子类只须要实现AbstractLifeCycle中增长的doStart和doStop实现子类具体的启动和中止，具体请参考【Jetty - LifeCycle源码分析】htm
ContainerLifeCycle.Bean：内部类，表示管理的Bean对象。对象
ContainerLifeCycle.Managed：内部类，被管理的Bean有几种类型：POJO，MANAGED，UNMANAGED，AUTO。blog
2.2 doStart和doStop
启动主要分为以下两个步骤：
（1）设置标志位_doStart = true；
（2）启动具备生命周期的bean（a）若是托管bean而且未运行的，则启动（b）若是是自动bean而且运行中，则设置为未托管；未运行的，则设置为托管，而且启动；
// 以添加的顺序启动托管的bean
@Override
protected void doStart() throws Exception
{
if (_destroyed)
throw new IllegalStateException("Destroyed container cannot be restarted");
// 标示已经启动，addBean能够启动其余的bean
_doStarted = true;
// 启动托管和自动beans
for (Bean b : _beans) // 遍历全部bean
{
if (b._bean instanceof LifeCycle)
{
LifeCycle l = (LifeCycle)b._bean;
switch(b._managed)
{
case MANAGED: // 若是是托管bean，而且未运行，则启动
if (!l.isRunning())
start(l);
break;
case AUTO: // 若是是自动bean
if (l.isRunning()) // 若是已经运行了，则设置为未托管
unmanage(b);
else // 若是未运行，设置为托管，而且启动
{
manage(b);
start(l);
}
break;
}
}
}
// 此处调用父类的doStart方法，就是AbstractLifeCycle的doStart方法，实际上是个空实现
super.doStart();
}
中止主要分为两个步骤：
（1）设置标志位；
（2）逆序中止具备生命周期的托管bean，为何逆序？主要与启动顺序比较，防止bean之间有关联出现错误，相似资源释放。
// 以添加的逆序中止具备生命周期的托管bean
@Override
protected void doStop() throws Exception
{
_doStarted = false; // 设置中止状态位
super.doStop(); // 调用AbstractLifeCycle的doStop方法，实际上是个空方法
List<Bean> reverse = new ArrayList<>(_beans);
Collections.reverse(reverse); // 逆序
for (Bean b : reverse)
{ // 具备生命周期而且托管的bean
if (b._managed==Managed.MANAGED && b._bean instanceof LifeCycle)
{
LifeCycle l = (LifeCycle)b._bean;
stop(l);
}
}
}
2.3 addBean
// o：bean，managed：bean类型
// 注意基本原则：在ContainerLifeCycle类里面有两个字段_beans和_listener，若是添加的bean也是Container.Listener类型，则须要在_listener里面也增长一个
public boolean addBean(Object o, Managed managed)
{
if (o==null || contains(o)) // 若是bean为null或者已经存在
return false;
Bean new_bean = new Bean(o); // 包装为Bean对象
// 若是bean是Container.Listener
if (o instanceof Container.Listener)
addEventListener((Container.Listener)o);
// 添加bean
_beans.add(new_bean);
// 通知全部_listeners，有新bean添加的事件
for (Container.Listener l:_listeners)
l.beanAdded(this,o);
try
{
switch (managed)
{
case UNMANAGED:
unmanage(new_bean);
break;
case MANAGED:
manage(new_bean);
// 若是ContainerLifeCycle在启动中，即调用doStart尚未退出
if (isStarting() && _doStarted)
{ // 此处o是一个任意类型且是个public方法，此处直接转为LifeCycle是否有问题？
LifeCycle l = (LifeCycle)o;
// 为何有这样的判断？
// doStart的过程（1）设置状态位（2）以bean添加的顺序启动具备生命周期的bean，若是此时调用了addBean有可能同步的问题，致使新添加的bean没有经过doStart启动，因此须要在此处判断若是未启动，则启动一下
if (!l.isRunning())
start(l);
}
break;
case AUTO:
if (o instanceof LifeCycle)
{
LifeCycle l = (LifeCycle)o;
if (isStarting()) // 若是ContainerLifeCycle启动中
{
if (l.isRunning()) // 若是bean运行中，则设置为未托管，不须要ContainerLifeCycle管理启动
unmanage(new_bean);
else if (_doStarted) // 若是bean未运行，而且ContainerLifeCyle启动中，则设置为托管bean而且启动之
{
manage(new_bean);
start(l);
}
else
new_bean._managed=Managed.AUTO;
}
else if (isStarted()) // 若是ContainerLifeCycle已经启动
unmanage(new_bean);
else // ContainerLifeCycle未启动
new_bean._managed=Managed.AUTO;
}
else
new_bean._managed=Managed.POJO;
break;
case POJO:
new_bean._managed=Managed.POJO;
}
}
catch (RuntimeException | Error e)
{
throw e;
}
catch (Exception e)
{
throw new RuntimeException(e);
}
if (LOG.isDebugEnabled())
LOG.debug("{} added {}",this,new_bean);
return true;
}
// 删除bean
private boolean remove(Bean bean)
{
if (_beans.remove(bean))
{
boolean wasManaged = bean.isManaged(); // bean是不是托管类型
unmanage(bean); // 设置bean为未托管类型
for (Container.Listener l:_listeners) // 通知监听器
l.beanRemoved(this,bean._bean);
// 若是被remove的bean是Listener，须要调用removeEventListener
if (bean._bean instanceof Container.Listener)
removeEventListener((Container.Listener)bean._bean);
// 若是是具备生命周期托管的bean须要中止。
if (wasManaged && bean._bean instanceof LifeCycle)
{
try
{
stop((LifeCycle)bean._bean);
}
catch(RuntimeException | Error e)
{
throw e;
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
return true;
}
return false;
}
2.4 插播Container管理bean的规则
经过前面的doStart和addBean能够基本肯定Container管理bean的以下几条规则：
ContainerLifeCycle是对容器化bean组件的一个生命周期的实现。
bean能够做为托管bean或未托管bean放入ContainerLifeCycle里面。
托管bean的启动中止和销毁由ContainerLifeCycle控制；未托管主要是为了dump，它们的生命周期必须独立管理。
当一个没有指定类型具备生命周期的bean加入到ContainerLifeCycle，ContianerLifeCycle能够推断它的类型：
（1）若是增长的bean运行中，它将以未托管类型加入container；
（2）若是增长的bean未运行且container也未运行，它将以AUTO类型加入container；
（3）若是增长的bean未运行且container在启动中，它将以托管类型加入container；
（4）若是增长的bean未运行且container已经启动，它将以未托管类型加入container；
当container已经启动，全部的托管bean也应该启动。
任何AUTO类型的bean都将依据它们的状态被分为托管或未托管，若是已经启动则为未托管，不然将启动它们而后设置为托管类型。
Contianer启动以后添加的bean将不会被启动，它们的状态须要显式管理。
当中止Container的时候，只有被这个Container启动的bean才会中止。
若是一个bean被多个Container共享，那么该bean只能是未托管的，即在增长以前，应该被启动
2.4.1 实例
2.5 manage和unmanage
manage是设置bean为托管类型，unmanage设置bean为未托管类型。
能够理解为两个相反的操做，须要注意若是被设置的bean是个Container，则须要将当前_listeners里面全部类型为InheritedListener的监听器添加到该bean里面或从该bean里面移除。
// 托管bean
private void manage(Bean bean)
{
if (bean._managed!=Managed.MANAGED)
{
bean._managed=Managed.MANAGED; // 设置bean为托管
if (bean._bean instanceof Container)
{
for (Container.Listener l:_listeners)
{
if (l instanceof InheritedListener) // 若是当前bean的listener里面有是InheritedListener须要增长到bean的_beans列表中
{
if (bean._bean instanceof ContainerLifeCycle)
((ContainerLifeCycle)bean._bean).addBean(l,false);
else
((Container)bean._bean).addBean(l);
}
}
}
if (bean._bean instanceof AbstractLifeCycle)
{
((AbstractLifeCycle)bean._bean).setStopTimeout(getStopTimeout());
}
}
}
// 未托管bean
private void unmanage(Bean bean)
{
if (bean._managed!=Managed.UNMANAGED)
{
if (bean._managed==Managed.MANAGED && bean._bean instanceof Container)
{
for (Container.Listener l:_listeners)
{ // 若是监听器是InheritedListener，须要将其从未托管的bean中移除
if (l instanceof InheritedListener)
((Container)bean._bean).removeBean(l);
}
}
bean._managed=Managed.UNMANAGED;
}
}
2.6 addEventListener和removeEventListener
两个是相反的操做，一个是增长Listener，另外一个是删除Listener。
若是待操做的Listener是InheritedListener子类，须要级联操做。
@Override
public void addEventListener(Container.Listener listener)
{
if (_listeners.contains(listener))
return;
_listeners.add(listener);
// 新加的Listener须要被告知全部bean
for (Bean b:_beans)
{
listener.beanAdded(this,b._bean);
// 若是是InheritedListener须要增长到bean为Container的_beans列表中
if (listener instanceof InheritedListener && b.isManaged() && b._bean instanceof Container)
{
if (b._bean instanceof ContainerLifeCycle)
((ContainerLifeCycle)b._bean).addBean(listener, false);
else
((Container)b._bean).addBean(listener);
}
}
}
@Override
public void removeEventListener(Container.Listener listener)
{
if (_listeners.remove(listener))
{
// remove existing beans
for (Bean b:_beans)
{
listener.beanRemoved(this,b._bean);
// 与增长相反，须要级联移除
if (listener instanceof InheritedListener && b.isManaged() && b._bean instanceof Container)
((Container)b._bean).removeBean(listener);
}
}
}
2.7 updateBean
最后ContainerLifeCycle还提供了重载的updateBean，入参通常是一个老bean和一个新bean。
通常操做都是先删除老bean，而后增长新bean，都是复用上面提到的removeBean和addBean，不在详细描述。