Spring @PostConstruct、@PreDestroy、InitializingBean、SmartInitializingSingle、DisposableBean 实例初始化与销毁

目录

@PostConstruct 与 @PreDestroy

InitializingBean 实例初始化

DisposableBean 实例销毁

SmartInitializingSingleton 单实例初始化

---

@PostConstruct 与 @PreDestroy

1、@PostConstruct 类似于 Serclet 的 inti() 方法，当 Bean 初始化时执行标记的方法。

2、@PreDestroy 类似于 Servlet 的 destroy() 方法，当 Bean 销毁时执行标记的方法。

3、下面以一个示例进行演示，提供一个 Spring 组件，交由 Spring 容器管理：

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.io.File;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicLong;
import static java.lang.System.getProperty;
/**
 * 用一个组件来模拟记录一个网站被访问的总次数
 * 1）用户每访问一次，总次数就加1
 * 2）总次数可以存储在数据库，这里直接以文件的形式存储在磁盘上
 * 3）显然如果每次访问都读写磁盘，并不明智，这里刚好利用初始化与销毁这两个时机做缓存处理
 */
@Component
public class DataCacheComponent {
    //网站访问次数。使用原子类，高并发性能更好。
    private static AtomicLong numberOfVisits = new AtomicLong(0);
    //数据物理文件名称
    private static final String fileName = "f838e6f4-b35e-49b6-a38e-106fec99f387.json";

    /**
     * 应用启动，DataCacheComponent bean 初始化时执行以下操作：
     * 1、读取指定路径下的数据文件，不存在时创建
     * 2、如果数据文件已经存在，则继续读取其中的内容，并将值赋值给成员静态变量 numberOfVisits
     * 3、后续直接操作内存中的 numberOfVisits，提供性能，避免频繁操作磁盘
     *
     * @throws IOException
     */
    @PostConstruct
    public void init() throws IOException {
        String java_home = getProperty("java.home");
        File temp_dir = new File(new File(java_home).getParent(), "temp");
        if (!temp_dir.exists()) {
            temp_dir.mkdirs();
        }
        File temp_file = new File(temp_dir, fileName);
        if (!temp_file.exists()) {
            temp_file.createNewFile();
        } else {
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode jsonNode = objectMapper.readTree(temp_file);
            if (jsonNode != null) {
                numberOfVisits.set(jsonNode.get("numberOfVisits").asLong());
            }
        }
        System.out.println("数据初始化完成：" + temp_file.getAbsolutePath() + "，numberOfVisits= " + this.numberOfVisits);
    }

    /**
     * 应用关闭，DataCacheComponent bean 销毁时执行以下操作：
     * 1、将内存中的 numberOfVisits 值持久化到磁盘文件
     *
     * @throws IOException
     */
    @PreDestroy
    public void destroy() throws IOException {
        JsonNodeFactory jsonNodeFactory = JsonNodeFactory.instance;
        ObjectNode objectNode = jsonNodeFactory.objectNode();
        objectNode.put("numberOfVisits", numberOfVisits.get());

        String java_home = getProperty("java.home");
        File temp_dir = new File(new File(java_home).getParent(), "temp");
        File temp_file = new File(temp_dir, fileName);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.writeValue(temp_file, objectNode);
        System.out.println("实例销毁，应用关闭，网站当前访问总次数：" + numberOfVisits.get());
    }

    //访问次数加1，用于其他地方调用
    public long numberOfVisitsAdd() {
        long l = DataCacheComponent.numberOfVisits.addAndGet(1L);
        System.out.println("网站当前访问总次数：" + l);
        return l;
    }
}

4、提供一个控制层方法进程访问测试：

import com.wmx.web_app.component.DataCacheComponent;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
public class VisitsController {
    @Resource
    private DataCacheComponent dataCacheComponent;
    //http://localhost:8080/visitsTest
    @GetMapping("visitsTest")
    public String visitsTest() {
        return String.valueOf(dataCacheComponent.numberOfVisitsAdd());
    }
}

InitializingBean 实例初始化

1、除了上面的的  PostConstruct 注解方式，也可以实现 InitializingBean 接口及其 afterPropertiesSet 方法。

2、InitializingBean 是要由 bean 实现的接口，这些 bean 需要在 BeanFactory 设置了所有属性后做出反应：例如 执行自定义初始化，或仅检查是否设置了所有强制属性。

3、InitializingBean 是在每一个bean 初始化完成后调用，多实例的情况下每初始化一次就调用一次。

DisposableBean 实例销毁

1、有时候需要在关闭 Spring 容器前，做一些额外的工作，比如：关闭资源文件等，此时除了上面的 @PreDestroy 注解，还可以实现 DisposableBean 接口及其 destroy 方法。

@RestController
public class LogbackController implements InitializingBean, DisposableBean {
    private static final Logger log = (Logger) LoggerFactory.getLogger(LogbackController.class);
    /**
     * 实现 InitializingBean 接口
     * 程序启动，当 Bean 初始化时，自动执行 afterPropertiesSet 方法。
     * 类似 @PostConstruct 注解。
     *
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("实例初始化完成！");
    }
    /**
     * 由希望在实例销毁时释放资源的 bean 实现 DisposableBean 接口。
     * 类似 @PreDestroy 注解，当实例销毁时，自动执行 destroy 方法。
     *
     * @throws Exception
     */
    @Override
    public void destroy() throws Exception {
        log.info("实例销毁...");
    }
}

src/main/java/com/wmx/yuanyuan/controller/LogbackController.java · 汪少棠/yuanyuan - Gitee.com

SmartInitializingSingleton 单实例初始化

1、SmartInitializingSingleton 是 spring 4.1 中引入的新特效，与 InitializingBean 的功能类似，都是 bean 实例化后执行自定义初始化，都是属于 spring bean 生命周期的增强。

2、InitializingBean 是在每一个bean 初始化完成后调用，多实例的情况下每初始化一次就调用一次。

3、SmartInitializingSingleton 是所有的非延迟的、单实例的 bean 都初始化后调用，只调用一次，多实例的 bean 不会调用。

4、SmartInitializingSingleton 接口中的 afterSingletonsInstantiated() 方法将会在所有的非惰性单实例 Bean 初始化完成之后进行回调。可以看作是在所有的 Bean 初始化完成结束后的InitializingBean 接口的替代。

SmartInitializingSingleton & InitializingBean 的区别
（1）SmartInitializingSingleton 接口只能作用于非惰性单实例 Bean，InitializingBean 接口无此要求。
（2）SmartInitializingSingleton 接口是在所有非惰性单实例初始化完成之后进行激活回调，InitializingBean 接口是在每一个 Bean 实例初始化完成之后进行激活回调。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.SmartInitializingSingleton;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SystemController implements SmartInitializingSingleton {
    private static final Logger LOG = LoggerFactory.getLogger(SystemController.class);
    /**
     * singleton 单例时，应用一启动，就会默认执行无参构造器创建实例，放到容器中。
     * prototype 多例时，则是到获取实例的时候，才进行创建。
     */
    public SystemController() {
        System.out.println("SystemController 构造器执行...");
    }
}