org.frameworkset.spi.Lifecycle Maven / Gradle / Ivy
Show all versions of bboss-core Show documentation
package org.frameworkset.spi;
/**
* A common interface defining methods for start/stop lifecycle control.
* The typical use case for this is to control asynchronous processing.
* NOTE: This interface does not imply specific auto-startup semantics.
* Consider implementing {@link SmartLifecycle} for that purpose.
*
* Can be implemented by both components (typically a Spring bean defined in a
* Spring context) and containers (typically a Spring {@link ApplicationContext}
* itself). Containers will propagate start/stop signals to all components that
* apply within each container, e.g. for a stop/restart scenario at runtime.
*
*
Can be used for direct invocations or for management operations via JMX.
* In the latter case, the
* will typically be defined with an
* ,
* restricting the visibility of activity-controlled components to the Lifecycle
* interface.
*
*
Note that the Lifecycle interface is only supported on top-level singleton
* beans. On any other component, the Lifecycle interface will remain undetected
* and hence ignored. Also, note that the extended {@link SmartLifecycle} interface
* provides integration with the application context's startup and shutdown phases.
*
* @author Juergen Hoeller
* @since 2.0
* @see SmartLifecycle
* @see ConfigurableApplicationContext
*/
public interface Lifecycle {
/**
* Start this component.
*
Should not throw an exception if the component is already running.
*
In the case of a container, this will propagate the start signal to all
* components that apply.
* @see SmartLifecycle#isAutoStartup()
*/
void start();
/**
* Stop this component, typically in a synchronous fashion, such that the component is
* fully stopped upon return of this method. Consider implementing {@link SmartLifecycle}
* and its {@code stop(Runnable)} variant when asynchronous stop behavior is necessary.
*
Note that this stop notification is not guaranteed to come before destruction: On
* regular shutdown, {@code Lifecycle} beans will first receive a stop notification before
* the general destruction callbacks are being propagated; however, on hot refresh during a
* context's lifetime or on aborted refresh attempts, only destroy methods will be called.
*
Should not throw an exception if the component isn't started yet.
*
In the case of a container, this will propagate the stop signal to all components
* that apply.
* @see SmartLifecycle#stop(Runnable)
* @see DisposableBean#destroy()
*/
void stop();
/**
* Check whether this component is currently running.
*
In the case of a container, this will return {@code true} only if all
* components that apply are currently running.
* @return whether the component is currently running
*/
boolean isRunning();
}