RefreshScope刷新@ConfigurationProperties配置bean后访问配置bean有概率读取到旧值

@Component
@RequiredArgsConstructor
@Slf4j
public class ApolloAutoRefreshConfig implements BeanPostProcessor {
 
    public static final String APOLLO_NAMESPACES = "${apollo.bootstrap.namespaces}";
    private final RefreshScope refreshScope;
    private final Environment environment;
 
    private final List<PostRefreshConfigChangeListener> listeners;
    private static final String NAMESPACE_DELIMITER = ",";
    private static final Splitter NAMESPACE_SPLITTER = Splitter.on(NAMESPACE_DELIMITER)
        .omitEmptyStrings().trimResults();
 
    @ApolloConfigChangeListener(value = APOLLO_NAMESPACES)
    @Trace
    public void onChange(ConfigChangeEvent changeEvent) {
        refreshScope.refreshAll();
        log.info("Apollo config refreshed, namespace: {}, keys: {}", changeEvent.getNamespace(), changeEvent.changedKeys());
        for (PostRefreshConfigChangeListener listener : listeners) {
            if (listenerInterestedInEvent(listener, changeEvent)) {
                listener.onChange(changeEvent);
            }
        }
    }
 
    private boolean listenerInterestedInEvent(PostRefreshConfigChangeListener listener, ConfigChangeEvent changeEvent) {
        String namespace = changeEvent.getNamespace();
        Set<String> changedKeys = changeEvent.changedKeys();
        Set<String> interestedNamespaces = listener.getNamespaces();
        Set<String> interestedKeys = listener.getInterestedKeys();
        Set<String> interestedKeyPrefixes = listener.getInterestedKeyPrefixes();
        if (!interestedNamespaces.contains(namespace)) {
            return false;
        }
        if (CollectionUtils.isEmpty(interestedKeys) && CollectionUtils.isEmpty(interestedKeyPrefixes)) {
            return true;
        }
        if (interestedKeys != null) {
            for (String interestedKey : interestedKeys) {
                if (changedKeys.contains(interestedKey)) {
                    return true;
                }
            }
        }
        if (interestedKeyPrefixes != null) {
            for (String prefix : interestedKeyPrefixes) {
                for (String changedKey : changedKeys) {
                    if (changedKey.startsWith(prefix)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
 
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        Class<?> clazz = bean.getClass();
 
        List<Method> methods = new ArrayList<>();
        ReflectionUtils.doWithMethods(clazz, methods::add);
 
        for (Method method : methods) {
            PostRefreshApolloConfigChangeListener annotation = AnnotationUtils
                .findAnnotation(method, PostRefreshApolloConfigChangeListener.class);
            if (annotation == null) {
                continue;
            }
            Class<?>[] parameterTypes = method.getParameterTypes();
            Preconditions.checkArgument(parameterTypes.length == 1,
                "Invalid number of parameters: %s for method: %s, should be 1", parameterTypes.length,
                method);
            Preconditions.checkArgument(ConfigChangeEvent.class.isAssignableFrom(parameterTypes[0]),
                "Invalid parameter type: %s for method: %s, should be ConfigChangeEvent", parameterTypes[0],
                method);
 
            ReflectionUtils.makeAccessible(method);
            String[] namespaces = annotation.value();
            String[] annotatedInterestedKeys = annotation.interestedKeys();
            String[] annotatedInterestedKeyPrefixes = annotation.interestedKeyPrefixes();
 
            Set<String> resolvedNamespaces = new HashSet<>();
            for (String namespace : namespaces) {
                String resolvedNamespace = environment.resolveRequiredPlaceholders(namespace);
                if (resolvedNamespace.contains(NAMESPACE_DELIMITER)) {
                    resolvedNamespaces.addAll(NAMESPACE_SPLITTER.splitToList(resolvedNamespace));
                } else {
                    resolvedNamespaces.add(resolvedNamespace);
                }
            }
 
            Set<String> interestedKeys =
                annotatedInterestedKeys.length > 0 ? Sets.newHashSet(annotatedInterestedKeys) : null;
            Set<String> interestedKeyPrefixes =
                annotatedInterestedKeyPrefixes.length > 0 ? Sets.newHashSet(annotatedInterestedKeyPrefixes)
                    : null;
            PostRefreshConfigChangeListener listener = new PostRefreshConfigChangeListener(bean, method, resolvedNamespaces, interestedKeys, interestedKeyPrefixes);
            listeners.add(listener);
            log.info("add custom listener {}", beanName);
        }
        return bean;
    }
 
    @RequiredArgsConstructor
    @Getter
    public static class PostRefreshConfigChangeListener implements ConfigChangeListener {
        private final Object bean;
        private final Method method;
        private final Set<String> namespaces;
        private final Set<String> interestedKeys;
        private final Set<String> interestedKeyPrefixes;
 
        @Override
        public void onChange(ConfigChangeEvent configChangeEvent) {
            ReflectionUtils.invokeMethod(method, bean, configChangeEvent);
        }
    }
}

@RefreshScope
@Component
@ConfigurationProperties("props")
@Getter
@Setter
public class MyProps {
    private List<Pair> pairs;
 
    @Getter
    @Setter
    public static class Pair {
        private String k;
        private String v;
    }
}

@Component
@RequiredArgsConstructor
@Slf4j
public class MyListener {
 
    private final MyProps myProps;
    private Map<String, String> map;
 
    @PostRefreshApolloConfigChangeListener(value = "${apollo.bootstrap.namespaces}", interestedKeyPrefixes = {"props"})
    public void onChange(ConfigChangeEvent changeEvent) {
        this.map = myProps.getPairs().stream().collect(Collectors.toMap(Pair::getK, Pair::getV));
        log.info("Loaded Map: {}", this.map.keySet());
    }
}

props:
  pairs:
    - k: k1
      v: v1

props:
  pairs:
    - k: k1
      v: v1
    - k: k2
      v: v2

INFO [Apollo-Config-2] [TID: N/A] c.t.n.e.r.c.ApolloAutoRefreshConfig: Apollo config refreshed, namespace: application.yaml, keys: [props.pairs[1].v, props.pairs[1].k]
INFO [Apollo-Config-2] [TID: N/A] c.t.n.e.t.MyListener: Loaded Map: [k1]