1.6 自定义 Bean

作者: A文艺钦年 | 来源:发表于2018-05-14 14:53 被阅读18次

1.6.1 生命周期回调

如果要使用生命周期回调 Bean 需要实现 InitializingBean 和 DisposableBean
afterPropertiesSet 在属性设置好之后执行，destroy() 在 bean 销毁前执行

根据 JSR-250 的最佳实践，可以 @PostConstruct 和 @PreDestroy 注解的方式实现生命周期回调，这样的可以使你的 Bean 从 Spring 接口中解耦出来。
如果不想不引入注解，但仍想要移除耦合，请考虑使用init-method和destroy-method 来配置。

在 spring 框架内部使用 BeanPostProcessor 的实现类来处理这些回调接口，如果要定制自己的特性或者不满足业务，可以自己实现一个 BeanPostProcessor，具体参考 Container Extension Points

In addition to the initialization and destruction callbacks, Spring-managed objects may also implement the Lifecycle interface so that those objects can participate in the startup and shutdown process as driven by the container’s own lifecycle.

上一句话比较晦涩难懂，我的理解是你的 bean 如果实现了lifecycle 接口的话，就可以参与到容器自身生命周期（启动和关闭的过程）。看了一下源码，基本上容器自身也实现了Lifecycle接口。虽然很强大，但是也太复杂了。

初始化回调 (Initialization callbacks)

上面也说了，需要实现 org.springframework.beans.factory.InitializingBea 接口，在容器给你的bean 设置好必要的属性之后会调用这个回调方法。

void afterPropertiesSet() throws Exception;

<bean id="exampleInitBean" class="examples.AnotherExampleBean"/>

public class AnotherExampleBean implements InitializingBean {

    public void afterPropertiesSet() {
        // do some initialization work
    }
}

不推荐使用实现接口的方式，因为会对接口产生耦合。可以使用注解 @PostConstruct 或者指定一个 POJO 的实现方法。在下面的例子中使用的基于xml配置实现的:

<bean id="exampleInitBean" class="examples.ExampleBean" init-method="init"/>

public class ExampleBean {

    public void init() {
        // do some initialization work
    }
}

还显然，上一种并不是文档所说了 specify a POJO initialization method，我们可以看一个POJO的例子，这个后面会细讲。

public class Foo {

    public void init() {
        // initialization logic
    }
}

public class Bar {

    public void cleanup() {
        // destruction logic
    }
}

@Configuration
public class AppConfig {

    @Bean(initMethod = "init")
    public Foo foo() {
        return new Foo();
    }

    @Bean(destroyMethod = "cleanup")
    public Bar bar() {
        return new Bar();
    }
}

销毁回调(Destruction callbacks)

这个和初始化回调的过程是一样的，不一样的是这个回调方法是在容器销毁 bean 的时候调用的。

基于接口类 org.springframework.beans.factory.DisposableBean

void destroy() throws Exception;

<bean id="exampleInitBean" class="examples.AnotherExampleBean"/>

public class AnotherExampleBean implements DisposableBean {

    public void destroy() {
        // do some destruction work (like releasing pooled connections)
    }
}

基于xml配置

<bean id="exampleInitBean" class="examples.ExampleBean" destroy-method="cleanup"/>

public class ExampleBean {

    public void cleanup() {
        // do some destruction work (like releasing pooled connections)
    }
}

destroy-method 属性可以被设置成 inferred，spring 会自动探测 bean 里公开的 close 和 shutdown 方法(实现java.io.Closeable 和 java.lang.AutoCloseable接口都匹配), inferred 和 default-destroy-method 可以设置到 <beans> 节点上，这样可以减少配置和一致。(Default initialization and destroy methods
)

默认到初始化和销毁方法（Default initialization and destroy methods）

在 <beans> 节点设置默认到初始化方法和销毁方法，可以被覆盖。

<beans default-init-method="init">

    <bean id="blogService" class="com.foo.DefaultBlogService">
        <property name="blogDao" ref="blogDao" />
    </bean>

</beans>

public class DefaultBlogService implements BlogService {

    private BlogDao blogDao;

    public void setBlogDao(BlogDao blogDao) {
        this.blogDao = blogDao;
    }

    // this is (unsurprisingly) the initialization callback method
    public void init() {
        if (this.blogDao == null) {
            throw new IllegalStateException("The [blogDao] property must be set.");
        }
    }
}

AOP 拦截器不会能代理初始化回调函数，因为 bean 初始化之后，AOP 拦截器还没有初始化。

结合生命周期机制(Combining lifecycle mechanisms)

从 spring 2.5 开始，我们有3种方法控制生命周期的行为.

实现 InitializingBean 和 DisposableBean 接口
自定义 init() 和 destroy() 方法
使用 @PostConstruct 和 @PreDestroy 注解

如果一个bean使用了上述三种生命周期方法的话，并且有不同的方法名，则会调用三次。如果有相同的名字，则只会调用一次。

调用顺序如下：

注释
接口方法
自定义方法

启动和停止生命周期回调(Startup and shutdown callbacks)

该 Lifecycle 接口为任何具有自己生命周期要求的对象定义了基本方法（例如启动和停止一些后台进程）：

public interface Lifecycle {

    void start();

    void stop();

    boolean isRunning();
}

所有 spring 管理的对象都可以实现这个接口，当一个 ApplicationContext 收到一个启动或者停止的信号，它会级联调用该容器下所有实现 Lifecycle 接口的对象。值得一提的这个动作是委托给 LifecycleProcessor 处理的。（不得不说这代码写的很棒）

public interface LifecycleProcessor extends Lifecycle {

    void onRefresh();

    void onClose();
}

这里可以看到，LifecycleProcessor 本身继承了 Lifecycle ，并且新增加了两个方法。

org.springframework.context.Lifecycle 接口只是显示申明了 start 和 stop，如果上下文（容器？）刷新了，并不会再次调用 start。使用 org.springframework.context.SmartLifecycle 可以达到更加细粒度的控制，当然包括启动阶段和自动启动阶段。在正常关闭时，所有Lifecyclebean将在传播一般销毁回调之前首先收到停止通知; 然而，在上下文的生命周期中的热刷新或中止刷新尝试时，只会调用销毁方法。

启动和停止的调用顺序非常重要，如果是有依赖的两个对象，一般情况下，依赖方会在其依赖启动之后启动，在其依赖停止之前停止。（嗯，正常逻辑）但是，有时直接依赖关系是未知的。您可能只知道某种类型的对象应该在另一种类型的对象之前启动。在这些情况下，SmartLifecycle 接口有另一接口 getPhase() 可以解决此问题。

public interface Phased {

    int getPhase();
}

public interface SmartLifecycle extends Lifecycle, Phased {

    boolean isAutoStartup();

    void stop(Runnable callback);
}

当启动当时候，phase 值最小当先启动，当停止时候，phase 值最大的先启动。
不过有一种极端情况是，值为 Integer.MAX_VALUE 先最后启动和最先停止（因为该对象可能依赖到了其他 bean）
如果实现了 Lifecycle bean 因为没有 getPhase()，所以默认返回 0。（ getPhase() 是 SmartLifecycle 的接口）

SmartLifecycle 的 stop 接口有一个 callback 参数。看了一下源码好像是说，如果你想要异步停止的话，就要调用这个 callback 的 run 方法。

 public void stop(Runnable callback) {
        try {
            this.stop();
        } finally {
            callback.run();
        }
    }

这个 callback 有一个超时的时间，默认 30 秒，当然可以修改在 xml 这个超时的值：

<bean id="lifecycleProcessor" class="org.springframework.context.support.DefaultLifecycleProcessor">
    <!-- timeout value in milliseconds -->
    <property name="timeoutPerShutdownPhase" value="10000"/>
</bean>

LifecycleProcessor 有两个接口：

onRefresh
onClose

只有容器 close 的时候，onClose 方法才会调用。stop() 和 onClose() 是有区别的

当容器刷新的时候，如果 bean 是实现了 SmartLifecycle 接口，并且 isAutoStartup() 方法，那么该 bean 的 start() 方法会调用.

if (!bean.isRunning() &&
                    (!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Starting bean '" + beanName + "' of type [" + bean.getClass() + "]");
                }
                try {
                    bean.start();
                }
                catch (Throwable ex) {
                    throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Successfully started bean '" + beanName + "'");
                }
            }

在非web应用中优雅的停止 Spring IoC 容器

Spring’s web-based ApplicationContext 的应用已经实现了容器的关闭（当应用关闭的时候）。

在非 web 应用中（如桌面客户端应用），如果要优雅的关闭容器，需要在 JVM 中注册一个 shutdown 的钩子。为了释放一些相关的资源，在 bean 中实现销毁回调是必要的。

直接调用容器的接口就行了，非常简单。。。

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public final class Boot {

    public static void main(final String[] args) throws Exception {
        ConfigurableApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

        // add a shutdown hook for the above context...
        ctx.registerShutdownHook();

        // app runs here...

        // main method exits, hook is called prior to the app shutting down...
    }
}

1.6 自定义 Bean

1.6.1 生命周期回调

初始化回调 (Initialization callbacks)

销毁回调(Destruction callbacks)

默认到初始化和销毁方法（Default initialization and destroy methods）

结合生命周期机制(Combining lifecycle mechanisms)

启动和停止生命周期回调(Startup and shutdown callbacks)

在非web应用中优雅的停止 Spring IoC 容器

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读