Class ContainerLifeCycle
- All Implemented Interfaces:
Container
,Destroyable
,Dumpable
,Dumpable.DumpableContainer
,LifeCycle
- Direct Known Subclasses:
AbstractConnectionFactory
,AbstractConnectionPool
,AbstractConnector
,AbstractHandler
,AbstractHttpClientTransport
,AbstractLoginService
,AbstractNCSARequestLog
,AbstractSessionCache
,AbstractSessionDataStore
,AttributeContainerMap
,CachingSessionDataStore
,ConfigurableSpnegoLoginService
,CustomRequestLog
,DefaultSessionIdManager
,EatWhatYouKill
,ExecutorThreadPool
,HttpClient
,HttpDestination
,JAASLoginService
,KeyStoreScanner
,LeakTrackingByteBufferPool
,LowResourceMonitor
,ManagedSelector
,QueuedThreadPool
,SelectorManager
LifeCycle
implementation for a collection of contained beans.
Beans can be added to the ContainerLifeCycle either as managed beans or as unmanaged beans.
A managed bean is started, stopped and destroyed with the aggregate.
An unmanaged bean is associated with the aggregate for the purposes of dump()
, but its
lifecycle must be managed externally.
When a LifeCycle
bean is added without a managed state being specified the state is
determined heuristically:
- If the added bean is running, it will be added as an unmanaged bean.
- If the added bean is !running and the container is !running, it will be added as an AUTO bean (see below).
- If the added bean is !running and the container is starting, it will be added as a managed bean and will be started (this handles the frequent case of new beans added during calls to doStart).
- If the added bean is !running and the container is started, it will be added as an unmanaged bean.
When stopping the container, a contained bean will be stopped by this aggregate only if it is started by this aggregate.
The methods addBean(Object, boolean)
, manage(Object)
and unmanage(Object)
can be used to
explicitly control the life cycle relationship.
If adding a bean that is shared between multiple ContainerLifeCycle
instances, then it should be started
before being added, so it is unmanaged, or the API must be used to explicitly set it as unmanaged.
This class also provides utility methods to dump deep structures of objects. In the dump, the following symbols are used to indicate the type of contained object:
SomeContainerLifeCycleInstance +- contained POJO instance += contained MANAGED object, started and stopped with this instance +~ referenced UNMANAGED object, with separate lifecycle +? referenced AUTO object that could become MANAGED or UNMANAGED.
-
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionprivate static class
(package private) static enum
Nested classes/interfaces inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle
AbstractLifeCycle.AbstractLifeCycleListener
Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.Container
Container.InheritedListener, Container.Listener
Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.Dumpable
Dumpable.DumpableContainer
Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.LifeCycle
LifeCycle.Listener
-
Field Summary
FieldsModifier and TypeFieldDescriptionprivate final List
<ContainerLifeCycle.Bean> private boolean
private boolean
private final List
<Container.Listener> private static final Logger
-
Constructor Summary
Constructors -
Method Summary
Modifier and TypeMethodDescriptionboolean
Adds the given bean, detecting whether to manage it or not.boolean
Adds the given bean, explicitly managing it or not.private boolean
addBean
(Object o, ContainerLifeCycle.Managed managed) void
addEventListener
(Container.Listener listener) Add an event listener.void
addManaged
(LifeCycle lifecycle) Adds a managed lifecycle.boolean
void
destroy()
Destroys the managed Destroyable beans in the reverse order they were added.protected void
doStart()
Starts the managed lifecycle beans in the order they were added.protected void
doStop()
Stops the managed lifecycle beans in the reverse order they were added.dump()
void
dump
(Appendable out) Dump this object to an Appendable with no indent.void
dump
(Appendable out, String indent) Dump this object (and children) into an Appendable using the provided indent after any new lines.static void
dump
(Appendable out, String indent, Collection<?>... collections) Deprecated.static String
Deprecated.protected void
dumpBeans
(Appendable out, String indent, Collection<?>... items) Deprecated.static void
dumpObject
(Appendable out, Object obj) Deprecated.useDumpable.dumpObject(Appendable, Object)
insteadprotected void
dumpObjects
(Appendable out, String indent, Object... items) Dump this object, it's contained beans and additional items to an Appendablevoid
Dumps toSystem.err
.protected void
dumpThis
(Appendable out) Deprecated.<T> T
private ContainerLifeCycle.Bean
getBeans()
<T> Collection
<T> <T> Collection
<T> getContainedBeans
(Class<T> clazz) protected <T> void
getContainedBeans
(Class<T> clazz, Collection<T> beans) boolean
boolean
Test if this container manages a beanboolean
isUnmanaged
(Object bean) void
Manages a bean already contained by this aggregate, so that it is started/stopped/destroyed with this aggregate.private void
private boolean
boolean
removeBean
(Object o) Removes the given bean.void
Removes all beanvoid
removeEventListener
(Container.Listener listener) Remove an event listener.void
setBeans
(Collection<Object> beans) void
setStopTimeout
(long stopTimeout) protected void
Starts the given lifecycle.protected void
Stops the given lifecycle.void
Unmanages a bean already contained by this aggregate, so that it is not started/stopped/destroyed with this aggregate.private void
void
updateBean
(Object oldBean, Object newBean) void
updateBean
(Object oldBean, Object newBean, boolean managed) void
updateBeans
(Object[] oldBeans, Object[] newBeans) Methods inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle
addLifeCycleListener, getState, getState, getStopTimeout, isFailed, isRunning, isStarted, isStarting, isStopped, isStopping, removeLifeCycleListener, start, stop, toString
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
Methods inherited from interface org.eclipse.jetty.util.component.Dumpable.DumpableContainer
isDumpable
-
Field Details
-
LOG
-
_beans
-
_listeners
-
_doStarted
private boolean _doStarted -
_destroyed
private boolean _destroyed
-
-
Constructor Details
-
ContainerLifeCycle
public ContainerLifeCycle()
-
-
Method Details
-
doStart
Starts the managed lifecycle beans in the order they were added.- Overrides:
doStart
in classAbstractLifeCycle
- Throws:
Exception
-
start
Starts the given lifecycle.- Parameters:
l
- the lifecycle to start- Throws:
Exception
- if unable to start lifecycle
-
stop
Stops the given lifecycle.- Parameters:
l
- the lifecycle to stop- Throws:
Exception
- if unable to stop the lifecycle
-
doStop
Stops the managed lifecycle beans in the reverse order they were added.- Overrides:
doStop
in classAbstractLifeCycle
- Throws:
Exception
-
destroy
public void destroy()Destroys the managed Destroyable beans in the reverse order they were added.- Specified by:
destroy
in interfaceDestroyable
-
contains
- Parameters:
bean
- the bean to test- Returns:
- whether this aggregate contains the bean
-
isManaged
Description copied from interface:Container
Test if this container manages a bean -
isAuto
- Parameters:
bean
- the bean to test- Returns:
- whether this aggregate contains the bean in auto state
-
isUnmanaged
- Parameters:
bean
- the bean to test- Returns:
- whether this aggregate contains the bean in auto state
-
addBean
Adds the given bean, detecting whether to manage it or not. If the bean is aLifeCycle
, then it will be managed if it is not already started and not managed if it is already started. TheaddBean(Object, boolean)
method should be used if this is not correct, or themanage(Object)
andunmanage(Object)
methods may be used after an add to change the status. -
addBean
Adds the given bean, explicitly managing it or not. -
addBean
-
addManaged
Adds a managed lifecycle.This is a convenience method that uses addBean(lifecycle,true) and then ensures that the added bean is started iff this container is running. Exception from nested calls to start are caught and wrapped as RuntimeExceptions
- Parameters:
lifecycle
- the managed lifecycle to add
-
addEventListener
Description copied from interface:Container
Add an event listener.- Specified by:
addEventListener
in interfaceContainer
- Parameters:
listener
- the listener to add- See Also:
-
manage
Manages a bean already contained by this aggregate, so that it is started/stopped/destroyed with this aggregate. -
manage
-
unmanage
Unmanages a bean already contained by this aggregate, so that it is not started/stopped/destroyed with this aggregate. -
unmanage
-
getBeans
-
setBeans
-
getBeans
-
getBean
-
removeBeans
public void removeBeans()Removes all bean -
getBean
-
removeBean
Description copied from interface:Container
Removes the given bean. If the bean is-aContainer.Listener
, then also do an implicitContainer.removeEventListener(Listener)
.- Specified by:
removeBean
in interfaceContainer
- Parameters:
o
- the bean to remove- Returns:
- whether the bean was removed
-
remove
-
removeEventListener
Description copied from interface:Container
Remove an event listener.- Specified by:
removeEventListener
in interfaceContainer
- Parameters:
listener
- the listener to remove- See Also:
-
setStopTimeout
public void setStopTimeout(long stopTimeout) - Overrides:
setStopTimeout
in classAbstractLifeCycle
-
dumpStdErr
Dumps toSystem.err
.- See Also:
-
dump
-
dump
Deprecated.useDumpable.dump(Dumpable)
instead- Parameters:
dumpable
- the object to dump- Returns:
- the string representation of the given Dumpable
-
dump
Description copied from interface:Dumpable
Dump this object (and children) into an Appendable using the provided indent after any new lines. The indent should not be applied to the first object dumped.- Specified by:
dump
in interfaceDumpable
- Parameters:
out
- The appendable to dump toindent
- The indent to apply after any new lines.- Throws:
IOException
- if unable to write to Appendable
-
dump
Dump this object to an Appendable with no indent.- Parameters:
out
- The appendable to dump to.- Throws:
IOException
- May be thrown by the Appendable
-
dumpThis
Deprecated.Dump just this object, but not it's children. Typically used to implementdump(Appendable, String)
- Parameters:
out
- The appendable to dump to- Throws:
IOException
- May be thrown by the Appendable
-
dumpObject
Deprecated.useDumpable.dumpObject(Appendable, Object)
instead- Parameters:
out
- The Appendable to dump toobj
- The object to dump- Throws:
IOException
- May be thrown by the Appendable
-
dumpObjects
Dump this object, it's contained beans and additional items to an Appendable- Parameters:
out
- The appendable to dump toindent
- The indent to apply after any new linesitems
- Additional items to be dumped as contained.- Throws:
IOException
- May be thrown by the Appendable
-
dumpBeans
@Deprecated protected void dumpBeans(Appendable out, String indent, Collection<?>... items) throws IOException Deprecated.- Parameters:
out
- The appendable to dump toindent
- The indent to apply after any new linesitems
- Additional collections to be dumped- Throws:
IOException
- May be thrown by the Appendable
-
dump
@Deprecated public static void dump(Appendable out, String indent, Collection<?>... collections) throws IOException Deprecated.- Throws:
IOException
-
updateBean
-
updateBean
-
updateBeans
-
getContainedBeans
- Specified by:
getContainedBeans
in interfaceContainer
- Type Parameters:
T
- the Bean type- Parameters:
clazz
- the class of the beans- Returns:
- the list of beans of the given class from the entire Container hierarchy. The order is primarily depth first and secondarily added order.
-
getContainedBeans
-
Dumpable.dump(Dumpable)
instead