spring事件（二）--定义由spring管理生命周期的bean

一、简介

在spring开发中，有时我们需要定义和spring容器一样生命周期的bean,

即是当springp容器调用start()方法、或者stop方法时，自定义的bean也会做相应的处理。

达到此目的需要实现接口org.springframework.context.Lifecycle

二、Lifecycle接口

Lifecycle接口用于，当spring容器调用start()或stop()方法时，实现其接口的类也会调用相应的方法。

Lifecycle接口有三个方法：

start()：开始时调用的方法

stop():停止时调用的方法

isRunning()：判断当前bean是处于start状态还是stop状态

其源码如下：

/**
 * 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 {@link org.springframework.jmx.export.MBeanExporter}
 * will typically be defined with an
 * {@link org.springframework.jmx.export.assembler.InterfaceBasedMBeanInfoAssembler},
 * 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
 * @see org.springframework.jms.listener.AbstractMessageListenerContainer
 * @see org.springframework.scheduling.quartz.SchedulerFactoryBean
 */
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 org.springframework.beans.factory.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();

}

三、代码实例

1、自定义实现Lifecycle接口的带生命周期的bean

@Component
public class StuLifecycle implements Lifecycle {
    private boolean running = false;
    public void start() {
        System.out.println("stu start");
        running =true;
    }

    public void stop() {
        System.out.println("stu stop");
        running = false;
    }

    public boolean isRunning() {
        return running;
    }
}

2、测试

public class SpringSelfEventMain {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ctx.start();  //ContextStartedEvent事件发生
        ctx.stop();   //ContextStoppedEvent事件发生
        ctx.close();  //ContextClosedEvent事件发生
    }
}

运行结果:

stu start
stu stop