@RefreshScope导致@Scheduled失效

时间:2021-6-12 作者:qvyue

一、问题背景

需要在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 配置文件为例):


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注解,指定作用域名称
         * 
     * 

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. * 指定是否应将组件配置为作用域代理*,如果是,则指定代理是基于接口还是基于子类 *

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,这表示在没有指定其他作用域配置事,不应该创建任何作用域代理 *

Analogous to {@code } support in Spring XML. * 类似于Spring XML中的{@code }支持 * @see ScopedProxyMode */ ScopedProxyMode proxyMode() default ScopedProxyMode.DEFAULT; }

4.2 @RefreshScope

4.2.1 简单认识RefreshScope

/**
 * Convenience annotation to put a @Bean 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 keys = this.refresh.refresh();
            log.info("Refresh keys changed: " + keys);
        }
    }

}

之后调用ContextRefresher 的refresh方法:

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

    public synchronized Set refreshEnvironment() {
        //提取原环境变量属性
        Map before = extract(
                this.context.getEnvironment().getPropertySources());
        //创建新容器加载原配置
        addConfigFilesToEnvironment();
        //提取并比较变更的数据
        Set 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 errors = new ArrayList();
        Collection 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 {

    @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方法,添加缓存。

@RefreshScope导致@Scheduled失效
GenericScope的get

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

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:qvyue@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。