@RefreshScope导致@Scheduled失效

一、问题背景

需要在springboot项目中引入定时任务实现定时的功能，任务当中有一个参数是在nacos的配置中心中的，希望做到任务执行时可以动态的获取配置中的信息。

二、实现代码

配置文件

message:
  log:
    timeout: 30 #天

启动类

import com.botany.spore.liquibase.autoconfig.EnableLiquibase;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.cloud.client.SpringCloudApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.scheduling.annotation.EnableScheduling;

@EnableLiquibase
@EnableScheduling // 开启定时任务功能
@SpringCloudApplication
@EnableFeignClients
public class InboxModelApplication {

    public static void main(String[] args) {
        SpringApplication.run(InboxModelApplication.class, args);
    }

}

调度任务

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * description: 调度
 *
 * @author: weirx
 * @time: 2021/4/30 11:30
 */
@Slf4j
@RefreshScope
@Component
public class HistoryLogDeleteTask {

    @Value("${message.log.timeout}")
    private String timeout;

    @Scheduled(cron = "*/10 * * * * ?")
    public void execute() {
        log.info("thread id:{}", Thread.currentThread().getId());
        this.deleteHistoryLog();
    }

    private void deleteHistoryLog() {
        DateTime dateTime = DateUtil.offsetDay(new Date(), Integer.valueOf(timeout));
        log.info("删除时间：{}", dateTime);
    }

}

三、问题描述

如上实现方式，发现在配置文件修改后，调度任务就停止了。

四、RefreshScope原理

4.1 Scope

想要了解RefreshScope，就要先了解Scope。
org.springframework.beans.factory.config.Scope是在spring中就存在的，而RefreshScope是springcloud对Scope的一种特殊实现，用于实现配置、实例的热加载。

Scope，也称作用域，在 Spring IoC 容器是指其创建的 Bean 对象相对于其他 Bean 对象的请求可见范围。在 Spring IoC 容器中具有以下几种作用域：基本作用域（singleton、prototype），Web 作用域（reqeust、session、globalsession），自定义作用域。

4.1.1 spring配置xml

Spring 的作用域在装配 Bean 时就必须在配置文件中指明，配置方式如下（以 xml 配置文件为例）：

<!-- 具体的作用域需要在 scope 属性中定义 -->
<bean id="XXX" class="com.XXX.XXXXX" scope="XXXX" />

4.1.2 使用注解@Scope

下面是@Scope的源码：

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scope {

    /**
     * Alias for {@link #scopeName}.
     * @see #scopeName
     */
    @AliasFor("scopeName")
    String value() default "";

    /**
     * Specifies the name of the scope to use for the annotated component/bean.
         * 为带有@Componet和@Bean注解，指定作用域名称
         * 
     * <p>Defaults to an empty string ({@code ""}) which implies
         * 默认是个空字符串
         *
     * {@link ConfigurableBeanFactory#SCOPE_SINGLETON SCOPE_SINGLETON}.
     * @since 4.2 从4.2开始可以指定以下作用域
     * @see ConfigurableBeanFactory#SCOPE_PROTOTYPE 多实例
          -- 每次获取Bean的时候会有一个新的实例
     * @see ConfigurableBeanFactory#SCOPE_SINGLETON 单例
          -- 全局有且仅有一个实例
     * @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST
         -- 表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效
     * @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION
         -- 表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效
     * @see #value
     */
    @AliasFor("value")
    String scopeName() default "";

    /**
     * Specifies whether a component should be configured as a scoped proxy
     * and if so, whether the proxy should be interface-based or subclass-based.
         * 指定是否应将组件配置为作用域代理*，如果是，则指定代理是基于接口还是基于子类
     * <p>Defaults to {@link ScopedProxyMode#DEFAULT}, which typically indicates
     * that no scoped proxy should be created unless a different default
     * has been configured at the component-scan instruction level.
         * 默认是DEFAULT，这表示在没有指定其他作用域配置事，不应该创建任何作用域代理
     * <p>Analogous to {@code <aop:scoped-proxy/>} support in Spring XML.
         * 类似于Spring XML中的{@code <aop：scoped-proxy />}支持
     * @see ScopedProxyMode
     */
    ScopedProxyMode proxyMode() default ScopedProxyMode.DEFAULT;
}

4.2 @RefreshScope

4.2.1 简单认识RefreshScope

/**
 * Convenience annotation to put a <code>@Bean</code> definition in
 * {@link org.springframework.cloud.context.scope.refresh.RefreshScope refresh scope}.
 * Beans annotated this way can be refreshed at runtime and any components that are using
 * them will get a new instance on the next method call, fully initialized and injected
 * with all dependencies.
 * 用这种方式注释的Bean可以在运行时刷新，并且正在使用*的任何组件都将在下一个方法调用上获得一个新实例，  
 * 并对其进行完全初始化并注入*所有依赖项
 *
 * @author Dave Syer
 *
 */
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Scope("refresh")
@Documented
public @interface RefreshScope {

    /**
     * @see Scope#proxyMode()
     * @return proxy mode
     */
    ScopedProxyMode proxyMode() default ScopedProxyMode.TARGET_CLASS;

}

如上所示，该注解使用了@Scope，并默认了ScopedProxyMode.TARGET_CLASS; 属性，此属性的功能就是在创建一个代理，在每次调用的时候都用它来调用GenericScope get 方法来获取对象。GenericScope是SpringCloud对Scope的一个实现，Scope的源码如下，我们主要关注get方法：

    public interface Scope {
        /**
         * description: 核心操作，从基础范围返回带有指定名称的对象。
         * @param name 对象名称
         * @param objectFactory 函数式接口对象，用于创建对象
         */
        Object get(String name, ObjectFactory<?> objectFactory);

        /**
         * description: 从基本作用域删除指定对象
         * @param name
         * @return: java.lang.Object
         */
        @Nullable
        Object remove(String name);

        void registerDestructionCallback(String name, Runnable callback);

        @Nullable
        Object resolveContextualObject(String key);

        @Nullable
        String getConversationId();

    }
}

4.2.2 如何刷新的？

通过跟踪代码，发现是从以下位置开始整个刷新过程，下面这个监听会时时等待刷新的消息推送：

public class RefreshEventListener implements SmartApplicationListener {

    private static Log log = LogFactory.getLog(RefreshEventListener.class);

    private ContextRefresher refresh;

    private AtomicBoolean ready = new AtomicBoolean(false);

    public RefreshEventListener(ContextRefresher refresh) {
        this.refresh = refresh;
    }

    @Override
    public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
        return ApplicationReadyEvent.class.isAssignableFrom(eventType)
                || RefreshEvent.class.isAssignableFrom(eventType);
    }

    /**
      * description: 监听刷新消息
      * @param event
      * @return: void
      */
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ApplicationReadyEvent) {
            handle((ApplicationReadyEvent) event);
        }
        else if (event instanceof RefreshEvent) {
            handle((RefreshEvent) event);
        }
    }

    public void handle(ApplicationReadyEvent event) {
        this.ready.compareAndSet(false, true);
    }

   /**
    * description: 处理刷新消息
    * @param event
    * @return: void
    */
    public void handle(RefreshEvent event) {
        if (this.ready.get()) { // don't handle events before app is ready
            log.debug("Event received " + event.getEventDesc());
            Set<String> keys = this.refresh.refresh();
            log.info("Refresh keys changed: " + keys);
        }
    }

}

之后调用ContextRefresher 的refresh方法：

    public synchronized Set<String> refresh() {
         //刷新环境变量
        Set<String> keys = refreshEnvironment();
        //刷新scope
        this.scope.refreshAll();
        return keys;
    }

    public synchronized Set<String> refreshEnvironment() {
        //提取原环境变量属性
        Map<String, Object> before = extract(
                this.context.getEnvironment().getPropertySources());
        //创建新容器加载原配置
        addConfigFilesToEnvironment();
        //提取并比较变更的数据
        Set<String> keys = changes(before,
                extract(this.context.getEnvironment().getPropertySources())).keySet();
        //发布变更事件
        this.context.publishEvent(new EnvironmentChangeEvent(this.context, keys));
        return keys;
    }

下面重点关注RefreshScope.refreshAll()方法,发现其内部有一个调用父级的destroy方法，即GenericScope的destroy方法：

    @ManagedOperation(description = "Dispose of the current instance of all beans "
            + "in this scope and force a refresh on next method execution.")
    public void refreshAll() {
        super.destroy();
        this.context.publishEvent(new RefreshScopeRefreshedEvent());
    }

destroy()源码,清空缓存,这这时候之前存在的cache信息就都没有了：

    @Override
    public void destroy() {
        List<Throwable> errors = new ArrayList<Throwable>();
        Collection<BeanLifecycleWrapper> wrappers = this.cache.clear();
        for (BeanLifecycleWrapper wrapper : wrappers) {
            try {
                Lock lock = this.locks.get(wrapper.getName()).writeLock();
                lock.lock();
                try {
                    wrapper.destroy();
                }
                finally {
                    lock.unlock();
                }
            }
            catch (RuntimeException e) {
                errors.add(e);
            }
        }
        if (!errors.isEmpty()) {
            throw wrapIfNecessary(errors.get(0));
        }
        this.errors.clear();
    }

那么缓存被清空后，终于发现导致我们scheduler失效的原因了，那么我们要再次使其生效要怎么做呢？只需要触发GenericScope的get方法，就会帮我们创建新的bean，并加入到cache当中。

五、解决方案
经过上面的分析，我们已经对问题产生的原因有了大致的了解，关键就在于如何在修改配置后，再去调用get方法，使其添加到cache中。实际使用过程中，我们只要再次使用这个bean的对象就可以了。

通过前面的分析我们发现，刷新机制是通过Listener进行监听的，所以这里我们也进行监听，监听到之后进行一次定时方法的调用，代码如下：

package com.mvtech.inbox.infra.utils.scheduler;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.cloud.context.scope.refresh.RefreshScopeRefreshedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * description: 调度
 *  
 * @author: weirx
 * @time: 2021/4/30 11:30
 */
@Slf4j
@RefreshScope
@Component
public class HistoryLogDeleteTask implements ApplicationListener<RefreshScopeRefreshedEvent> {

    @Value("${message.log.timeout}")
    private String timeout;

    @Scheduled(cron = "*/10 * * * * ?")
    public void execute() {
        log.info("thread id:{}", Thread.currentThread().getId());
        this.deleteHistoryLog();
    }

    private void deleteHistoryLog() {
        if (StringUtils.isNotEmpty(timeout)) {
            DateTime dateTime = DateUtil.offsetDay(new Date(), Integer.valueOf(timeout));
            log.info("删除时间：{}", dateTime);
        }
    }

    @Override
    public void onApplicationEvent(RefreshScopeRefreshedEvent event) {
        this.execute();
    }
}

如上所示可以使定时任务bean重新添加到缓存cache当中。过程中调用了GenericScope的get方法，添加缓存。

GenericScope的get

以上就是整体原因的简单分析及解决方案。