Spring关闭执行销毁方法有几种，看完才知道SmartLifecycle最快

偏执的太偏执、 2024-05-06 21:29 23阅读 0赞

![773e0fbfe02846d794d64f1dc4b99a00.png][]

## 前言 ##

大家好，这段时间在写业务代码的时候用到了Spring容器关闭执行销毁方法来关闭正在执行中的业务。

学习了多种触发销毁方法的方式，由于业务场景不同，我们可能需要尽快的做销毁动作，或者最晚才执行销毁动作。

刚好最近在看RocketMQ的源码，发现了他的关闭方式和我们以往的不一样，他使用的SmartLifecycle不是那么多人

知道，但是他却能够在Spring容器一收到通知的时候，就调用销毁方法。

帮大家整理出来，给我们设计方案的时候提供更多的思路。

## 什么是Spring的扩展点？ ##

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

那他是什么？

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

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

![3d4b34edd44f4bd8a30e7ae50e96a8e5.png][]

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

![55697370b0f54d19b017e0281fc47fc8.png][]

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

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

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

## 业务场景 ##

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

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

对补偿机制的影响。

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

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

## 解决方案 ##

1.  将当前执行任务的redis锁记录下来
2.  在Spring应用关系的时候，调用销毁方法进行锁的释放
3.  采用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>>>>>");
        }
    }

1.  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;
        }
    }

1.  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>>>>>");
            }));
        }

1.  @PreDestroy注解

@PreDestroy
    public void preDestroy(){
        System.out.println("PreDestroy>>>>");
    }

1.  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()方法， 进行双重关闭，如果和destroy()先执行了，则将running设置为false，不在执行stop()

## 总结 ##

今天主要整理了一下，Spring的关闭扩展点，在日常的业务开发中，我们经常需要针对不同的场景设计合理的方案，

今天主要说了几种常用的方案，还有SmartLifecycle这种比较冷门的实现方式。

大家还知道哪些Spring容器关闭执行销毁方法，可以说出来一起交流一下~

根据我上面的业务场景，大家平时的处理方案是什么样的，都可以说一说。

[773e0fbfe02846d794d64f1dc4b99a00.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/bbea0eca4ea74efa9c5b92b234dca5e4.png
[3d4b34edd44f4bd8a30e7ae50e96a8e5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/4862cea78d64482c90d85be2a6138171.png
[55697370b0f54d19b017e0281fc47fc8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/ef99c1f98679474199b443cff20fa1de.png