Spring容器关闭执行销毁方法有几种？

什么是Spring的扩展点？

这个问题让我很深刻，记得之前有一个面试就被问到有没有使用过。

那他是什么？

先来看下Spring容器的加载过程

可以看到Bean从无到有主要是经历了四个步骤

就是在成熟态的时候，在初始化生命周期执行回调方法

主要是以接口或者注解的形式对外提供，注入到IOC容器中，完成对应的功能。

哪些场景下，我们需要使用退出前销毁

主要是希望在销毁之前在做一些事情，比如像池化技术正确的断开，JVM内存回收，还有业务逻辑执行。

业务场景

直接进入正题，我先说一说我的业务场景，在执行任务A的时候，这时候服务重启了，因为任务A加了分布式锁，所以在

重启服务的时候，补偿机制拿到了任务A发现锁依然被占用着，所以我就希望能够在应用关闭之前把锁给释放掉，减少

对补偿机制的影响。

补充：这里其实也可以用Redisson，来进行锁续期，一段时间过后自己释放，但是系统中更多时候使用简单的分布式

锁就可以满足，避免引入Redisson这么重的框架。

解决方案

将当前执行任务的redis锁记录下来

在Spring应用关系的时候，调用销毁方法进行锁的释放

采用SmartLifecycle和DisposableBean相互配合来执行destroy()方法

具体实现：

@Service

public class UserServiceImpl implements UserService, DisposableBean, SmartLifecycle {

    private volatile boolean running = false;

    private List<String> lockKeys = new ArrayList<>();

    @Resource

    HelloService helloService;

    @Override

    public void get() {

        String key = "redis:key";

        //伪代码

        RedissonUtil.lock(key);

        try {

            lockKeys.add(key);

        } catch (Exception ex){

            ex.printStackTrace();

            //...

        } finally {

            RedissonUtil.unlock(key);

            lockKeys.remove(key);

        }

    }

    @Override

    public void destroy() {

        // 删除正在执行中的key

        RedissonUtil.deletes(lockKeys);

        running = false;

    }

    @Override

    public void start() {

        System.out.println("start >>>>");

        running = true;

    }

    @Override

    public void stop() {

        System.out.println("stop >>>>");

        // 删除正在执行中的key

        RedissonUtil.deletes(lockKeys);

    }

    @Override

    public boolean isRunning() {

        return running;

    }

    @Override

    public int getPhase() {

        return Integer.MAX_VALUE;

    }

}

利用DisposableBean和SmartLifecycle进行双重的销毁机制，如果已经执行了DisposableBean的销毁方法

那可以修改running的值为false，就不会再进行stop()的执行了

Spring执行关闭的时机

1.JVM关闭

2.对象销毁时候

3.容器停止

关闭前执行销毁方法有哪些

1.DisposableBean

调用时机：Bean对象销毁的时候

@Service

public class UserServiceImpl implements UserService, DisposableBean {

    @Override

    public void destroy() {

        System.out.println("destroy>>>>>");

    }

}

2.SmartLifecycle

调用时机：Spring容器发出关闭通知

@Service

public class UserServiceImpl implements UserService, SmartLifecycle {

    @Override

    public void start() {

        System.out.println("start >>>>");

        running = true;

    }

    @Override

    public void stop() {

        System.out.println("stop >>>>");

    }

    @Override

    public boolean isRunning() {

        return running;

    }

    @Override

    public int getPhase() {

        return Integer.MAX_VALUE;

    }

}

3.InitializingBean

这个方式比较特殊，就是在初始化的时候，提前设置好了钩子函数addShutdownHook

调用时机：监听到JVM关闭

@Service

public class UserServiceImpl implements UserService, InitializingBean {

    @Override

    public void afterPropertiesSet() {

        Runtime.getRuntime().addShutdownHook(new Thread(() -> {

            helloService.get();

            System.out.println("addShutdownHook>>>>>");

        }));

    }

}

4.@PreDestroy注解

@PreDestroy

public void preDestroy(){

    System.out.println("PreDestroy>>>>");

}

5.Xml和@Bean绑定destoryMethod方法

对比执行结果：

SmartLifecycle > @PreDestroy,DisposableBean > addShutdownHook

2022-09-05 23:06:04.046 INFO 11807 --- [ main] c.l.d.SpringBootDemoDockerApplication : Started SpringBootDemoDockerApplication in 1.4 seconds (JVM running for 1.752)

ApplicationRunner>>>>>

CommandLineRunner>>>项目启动完毕后,倒数10秒关闭

thread1...

thread1...

thread1...

thread1...

stop >>>>

2022-09-05 23:06:14.054  INFO 11807 --- [          main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Shutting down ExecutorService 'applicationTaskExecutor'

PreDestroy>>>>

destroy>>>>>

thread1...

thread1...

get

addShutdownHook>>>>>

SmartLifecycle接口源码

了解一下SmartLifecycle接口到底由哪些组成的

/**

* 当上下文被刷新（所有对象已被实例化和初始化之后）时，将调用该方法

* isAutoStartup默认为true则调用start，否则需要自己手动调用

*/

@Override

public void start() {

    System.out.println("start >>>>");

    running = true;

}

/**

* 接口Lifecycle子类的方法，只有非SmartLifecycle的子类才会执行该方法。

* 1. 该方法只对直接实现接口Lifecycle的类才起作用，对实现SmartLifecycle接口的类无效。

* 2. 方法stop()和方法stop(Runnable callback)的区别只在于，后者是SmartLifecycle子类的专属。

*/

@Override

public void stop() {

    System.out.println("stop >>>>");

}

/**

* 只有该方法返回false时，start方法才会被执行

* 只有该方法返回true时，stop(Runnable callback)或stop()方法才会被执

* @return

*/

@Override

public boolean isRunning() {

    return running;

}

/**

* 返回 Integer.MAX_VALUE 仅表明

* 我们将是第一个关闭的 bean 和最后一个启动的 bean

* 关闭容器的第一时间调用stop()方法

*/

@Override

public int getPhase() {

    return Integer.MAX_VALUE;

}

/**

* 如果该`Lifecycle`类所在的上下文在调用`refresh`时,希望能够自己自动进行回调，则返回`true`,

* false的值表明组件打算通过显式的start()调用来启动，类似于普通的Lifecycle实现。

*/

@Override

public boolean isAutoStartup() {

    return false;

}

/**

* SmartLifecycle子类的才有的方法，当isRunning方法返回true时，该方法才会被调用。

* 很多框架中的源码中，都会把真正逻辑写在stop()方法内。

*/

@Override

public void stop(Runnable callback) {

    stop();

    // 如果你让isRunning返回true，需要执行stop这个方法

    // 在程序退出时，Spring的DefaultLifecycleProcessor会认为这个MySmartLifecycle没有stop完成，

    // 程序会一直卡着结束不了，等待一定时间（默认超时时间30秒）后才会自动结束。

    callback.run();

}

SmartLifecycle#isRunning判断是否已经执行，false表示还未执行

则调用SmartLifecycle#start()执行

当关闭的时候isRunning为ture已经执行

则调用SmartLifecycle#stop()执行

学习MQ如何进行退出前优雅执行销毁方法

DefaultRocketMQListenerContainer.class

public class DefaultRocketMQListenerContainer implements InitializingBean,

    RocketMQListenerContainer, SmartLifecycle, ApplicationContextAware {

    private final static Logger log = LoggerFactory.getLogger(DefaultRocketMQListenerContainer.class);

    private boolean running;

    ...

    @Override

    public void destroy() {

        this.setRunning(false);

        if (Objects.nonNull(consumer)) {

            consumer.shutdown();

        }

        log.info("container destroyed, {}", this.toString());

    }

    @Override

    public boolean isAutoStartup() {

        return true;

    }

    @Override

    public void stop(Runnable callback) {

        stop();

        callback.run();

    }

    @Override

    public void start() {

        if (this.isRunning()) {

            throw new IllegalStateException("container already running. " + this.toString());

        }

        try {

            consumer.start();

        } catch (MQClientException e) {

            throw new IllegalStateException("Failed to start RocketMQ push consumer", e);

        }

        this.setRunning(true);

        log.info("running container: {}", this.toString());

    }

    @Override

    public void stop() {

        if (this.isRunning()) {

            if (Objects.nonNull(consumer)) {

                consumer.shutdown();

            }

            setRunning(false);

        }

    }

    @Override

    public boolean isRunning() {

        return running;

    }

    private void setRunning(boolean running) {

        this.running = running;

    }

    @Override

    public int getPhase() {

        // Returning Integer.MAX_VALUE only suggests that

        // we will be the first bean to shutdown and last bean to start

        return Integer.MAX_VALUE;

    }

    @Override

    public void afterPropertiesSet() throws Exception {

        initRocketMQPushConsumer();

        this.messageType = getMessageType();

        this.methodParameter = getMethodParameter();

        log.debug("RocketMQ messageType: {}", messageType);

    }

}

RocketMQ在这里进行了几个步骤需要我们关注

1.他将getPhase的值设置为最大，在容器关闭的第一时间调用stop()方法

2.同时实现了SmartLifecycle和RocketMQListenerContainer接口,分别实现了stop()和destroy()方法，

3.进行双重关闭，如果和destroy()先执行了，则将running设置为false，不在执行stop()

原文链接：https://juejin.cn/post/7139920679683489823