SpringCloud配置刷新原理解析

/* * Copyright 2013-2014 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *  http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.cloud.endpoint;import java.util.Arrays;import java.util.Collection;import java.util.Set;import org.springframework.boot.actuate.endpoint.AbstractEndpoint;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.cloud.context.refresh.ContextRefresher;import org.springframework.jmx.export.annotation.ManagedOperation;import org.springframework.jmx.export.annotation.ManagedResource;/** * @author Dave Syer * @author Venil Noronha */@ConfigurationProperties(prefix = "endpoints.refresh", ignoreUnknownFields = false)@ManagedResourcepublic class RefreshEndpoint extends AbstractEndpoint<Collection<String>> { private ContextRefresher contextRefresher; public RefreshEndpoint(ContextRefresher contextRefresher) {  super("refresh");  this.contextRefresher = contextRefresher; } @ManagedOperation public String[] refresh() {  Set<String> keys = contextRefresher.refresh();  return keys.toArray(new String[keys.size()]); } @Override public Collection<String> invoke() {  return Arrays.asList(refresh()); }}

public synchronized Set<String> refresh() {  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(context, keys));  this.scope.refreshAll();  return keys; }

/* for testing */ ConfigurableApplicationContext addConfigFilesToEnvironment() {  ConfigurableApplicationContext capture = null;  try {   StandardEnvironment environment = copyEnvironment(     this.context.getEnvironment());   SpringApplicationBuilder builder = new SpringApplicationBuilder(Empty.class)     .bannerMode(Mode.OFF).web(false).environment(environment);   // Just the listeners that affect the environment (e.g. excluding logging   // listener because it has side effects)   builder.application()     .setListeners(Arrays.asList(new BootstrapApplicationListener(),       new ConfigFileApplicationListener()));   capture = builder.run();   if (environment.getPropertySources().contains(REFRESH_ARGS_PROPERTY_SOURCE)) {    environment.getPropertySources().remove(REFRESH_ARGS_PROPERTY_SOURCE);   }   MutablePropertySources target = this.context.getEnvironment()     .getPropertySources();   String targetName = null;   for (PropertySource<?> source : environment.getPropertySources()) {    String name = source.getName();    if (target.contains(name)) {     targetName = name;    }    if (!this.standardSources.contains(name)) {     if (target.contains(name)) {      target.replace(name, source);     }     else {      if (targetName != null) {       target.addAfter(targetName, source);      }      else {       // targetName was null so we are at the start of the list       target.addFirst(source);       targetName = name;      }     }    }   }  }  finally {   ConfigurableApplicationContext closeable = capture;   while (closeable != null) {    try {     closeable.close();    }    catch (Exception e) {     // Ignore;    }    if (closeable.getParent() instanceof ConfigurableApplicationContext) {     closeable = (ConfigurableApplicationContext) closeable.getParent();    }    else {     break;    }   }  }  return capture; }

builder.application().setListeners(Arrays.asList(new BootstrapApplicationListener(),       new ConfigFileApplicationListener()));

/* * Copyright 2012-2017 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *  http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.boot.context.config;import java.io.IOException;import java.util.ArrayList;import java.util.Arrays;import java.util.Collection;import java.util.Collections;import java.util.Iterator;import java.util.LinkedHashSet;import java.util.LinkedList;import java.util.List;import java.util.Queue;import java.util.Set;import org.apache.commons.logging.Log;import org.springframework.beans.BeansException;import org.springframework.beans.CachedIntrospectionResults;import org.springframework.beans.factory.config.BeanFactoryPostProcessor;import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;import org.springframework.boot.SpringApplication;import org.springframework.boot.bind.PropertiesConfigurationFactory;import org.springframework.boot.bind.PropertySourcesPropertyValues;import org.springframework.boot.bind.RelaxedDataBinder;import org.springframework.boot.bind.RelaxedPropertyResolver;import org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent;import org.springframework.boot.context.event.ApplicationPreparedEvent;import org.springframework.boot.env.EnumerableCompositePropertySource;import org.springframework.boot.env.EnvironmentPostProcessor;import org.springframework.boot.env.PropertySourcesLoader;import org.springframework.boot.logging.DeferredLog;import org.springframework.context.ApplicationEvent;import org.springframework.context.ConfigurableApplicationContext;import org.springframework.context.annotation.ConfigurationClassPostProcessor;import org.springframework.context.event.SmartApplicationListener;import org.springframework.core.Ordered;import org.springframework.core.annotation.AnnotationAwareOrderComparator;import org.springframework.core.convert.ConversionService;import org.springframework.core.convert.support.DefaultConversionService;import org.springframework.core.env.ConfigurableEnvironment;import org.springframework.core.env.EnumerablePropertySource;import org.springframework.core.env.MutablePropertySources;import org.springframework.core.env.PropertySource;import org.springframework.core.env.PropertySources;import org.springframework.core.io.DefaultResourceLoader;import org.springframework.core.io.Resource;import org.springframework.core.io.ResourceLoader;import org.springframework.core.io.support.SpringFactoriesLoader;import org.springframework.util.Assert;import org.springframework.util.ResourceUtils;import org.springframework.util.StringUtils;import org.springframework.validation.BindException;/** * {@link EnvironmentPostProcessor} that configures the context environment by loading * properties from well known file locations. By default properties will be loaded from * 'application.properties' and/or 'application.yml' files in the following locations: * <ul> * <li>classpath:</li> * <li>file:./</li> * <li>classpath:config/</li> * <li>file:./config/:</li> * </ul> * <p> * Alternative search locations and names can be specified using * {@link #setSearchLocations(String)} and {@link #setSearchNames(String)}. * <p> * Additional files will also be loaded based on active profiles. For example if a 'web' * profile is active 'application-web.properties' and 'application-web.yml' will be * considered. * <p> * The 'spring.config.name' property can be used to specify an alternative name to load * and the 'spring.config.location' property can be used to specify alternative search * locations or specific files. * <p> * Configuration properties are also bound to the {@link SpringApplication}. This makes it * possible to set {@link SpringApplication} properties dynamically, like the sources * ("spring.main.sources" - a CSV list) the flag to indicate a web environment * ("spring.main.web_environment=true") or the flag to switch off the banner * ("spring.main.show_banner=false"). * * @author Dave Syer * @author Phillip Webb * @author Stephane Nicoll * @author Andy Wilkinson * @author Eddú Meléndez */public class ConfigFileApplicationListener  implements EnvironmentPostProcessor, SmartApplicationListener, Ordered { private static final String DEFAULT_PROPERTIES = "defaultProperties"; // Note the order is from least to most specific (last one wins) private static final String DEFAULT_SEARCH_LOCATIONS = "classpath:/,classpath:/config/,file:./,file:./config/"; private static final String DEFAULT_NAMES = "application"; /**  * The "active profiles" property name.  */ public static final String ACTIVE_PROFILES_PROPERTY = "spring.profiles.active"; /**  * The "includes profiles" property name.  */ public static final String INCLUDE_PROFILES_PROPERTY = "spring.profiles.include"; /**  * The "config name" property name.  */ public static final String CONFIG_NAME_PROPERTY = "spring.config.name"; /**  * The "config location" property name.  */ public static final String CONFIG_LOCATION_PROPERTY = "spring.config.location"; /**  * The default order for the processor.  */ public static final int DEFAULT_ORDER = Ordered.HIGHEST_PRECEDENCE + 10; /**  * Name of the application configuration {@link PropertySource}.  */ public static final String APPLICATION_CONFIGURATION_PROPERTY_SOURCE_NAME = "applicationConfigurationProperties"; private final DeferredLog logger = new DeferredLog(); private String searchLocations; private String names; private int order = DEFAULT_ORDER; private final ConversionService conversionService = new DefaultConversionService(); @Override public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {  return ApplicationEnvironmentPreparedEvent.class.isAssignableFrom(eventType)    || ApplicationPreparedEvent.class.isAssignableFrom(eventType); } @Override public boolean supportsSourceType(Class<?> aClass) {  return true; } @Override public void onApplicationEvent(ApplicationEvent event) {  if (event instanceof ApplicationEnvironmentPreparedEvent) {   onApplicationEnvironmentPreparedEvent(     (ApplicationEnvironmentPreparedEvent) event);  }  if (event instanceof ApplicationPreparedEvent) {   onApplicationPreparedEvent(event);  } } private void onApplicationEnvironmentPreparedEvent(   ApplicationEnvironmentPreparedEvent event) {  List<EnvironmentPostProcessor> postProcessors = loadPostProcessors();  postProcessors.add(this);  AnnotationAwareOrderComparator.sort(postProcessors);  for (EnvironmentPostProcessor postProcessor : postProcessors) {   postProcessor.postProcessEnvironment(event.getEnvironment(),     event.getSpringApplication());  } } List<EnvironmentPostProcessor> loadPostProcessors() {  return SpringFactoriesLoader.loadFactories(EnvironmentPostProcessor.class,    getClass().getClassLoader()); } @Override public void postProcessEnvironment(ConfigurableEnvironment environment,   SpringApplication application) {  addPropertySources(environment, application.getResourceLoader());  configureIgnoreBeanInfo(environment);  bindToSpringApplication(environment, application); } private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {  if (System.getProperty(    CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME) == null) {   RelaxedPropertyResolver resolver = new RelaxedPropertyResolver(environment,     "spring.beaninfo.");   Boolean ignore = resolver.getProperty("ignore", Boolean.class, Boolean.TRUE);   System.setProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME,     ignore.toString());  } } private void onApplicationPreparedEvent(ApplicationEvent event) {  this.logger.replayTo(ConfigFileApplicationListener.class);  addPostProcessors(((ApplicationPreparedEvent) event).getApplicationContext()); } /**  * Add config file property sources to the specified environment.  * @param environment the environment to add source to  * @param resourceLoader the resource loader  * @see #addPostProcessors(ConfigurableApplicationContext)  */ protected void addPropertySources(ConfigurableEnvironment environment,   ResourceLoader resourceLoader) {  RandomValuePropertySource.addToEnvironment(environment);  new Loader(environment, resourceLoader).load(); } /**  * Bind the environment to the {@link SpringApplication}.  * @param environment the environment to bind  * @param application the application to bind to  */ protected void bindToSpringApplication(ConfigurableEnvironment environment,   SpringApplication application) {  PropertiesConfigurationFactory<SpringApplication> binder = new PropertiesConfigurationFactory<SpringApplication>(    application);  binder.setTargetName("spring.main");  binder.setConversionService(this.conversionService);  binder.setPropertySources(environment.getPropertySources());  try {   binder.bindPropertiesToTarget();  }  catch (BindException ex) {   throw new IllegalStateException("Cannot bind to SpringApplication", ex);  } } /**  * Add appropriate post-processors to post-configure the property-sources.  * @param context the context to configure  */ protected void addPostProcessors(ConfigurableApplicationContext context) {  context.addBeanFactoryPostProcessor(    new PropertySourceOrderingPostProcessor(context)); } public void setOrder(int order) {  this.order = order; } @Override public int getOrder() {  return this.order; } /**  * Set the search locations that will be considered as a comma-separated list. Each  * search location should be a directory path (ending in "/") and it will be prefixed  * by the file names constructed from {@link #setSearchNames(String) search names} and  * profiles (if any) plus file extensions supported by the properties loaders.  * Locations are considered in the order specified, with later items taking precedence  * (like a map merge).  * @param locations the search locations  */ public void setSearchLocations(String locations) {  Assert.hasLength(locations, "Locations must not be empty");  this.searchLocations = locations; } /**  * Sets the names of the files that should be loaded (excluding file extension) as a  * comma-separated list.  * @param names the names to load  */ public void setSearchNames(String names) {  Assert.hasLength(names, "Names must not be empty");  this.names = names; } /**  * {@link BeanFactoryPostProcessor} to re-order our property sources below any  * {@code @PropertySource} items added by the {@link ConfigurationClassPostProcessor}.  */ private class PropertySourceOrderingPostProcessor   implements BeanFactoryPostProcessor, Ordered {  private ConfigurableApplicationContext context;  PropertySourceOrderingPostProcessor(ConfigurableApplicationContext context) {   this.context = context;  }  @Override  public int getOrder() {   return Ordered.HIGHEST_PRECEDENCE;  }  @Override  public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)    throws BeansException {   reorderSources(this.context.getEnvironment());  }  private void reorderSources(ConfigurableEnvironment environment) {   ConfigurationPropertySources     .finishAndRelocate(environment.getPropertySources());   PropertySource<?> defaultProperties = environment.getPropertySources()     .remove(DEFAULT_PROPERTIES);   if (defaultProperties != null) {    environment.getPropertySources().addLast(defaultProperties);   }  } } /**  * Loads candidate property sources and configures the active profiles.  */ private class Loader {  private final Log logger = ConfigFileApplicationListener.this.logger;  private final ConfigurableEnvironment environment;  private final ResourceLoader resourceLoader;  private PropertySourcesLoader propertiesLoader;  private Queue<Profile> profiles;  private List<Profile> processedProfiles;  private boolean activatedProfiles;  Loader(ConfigurableEnvironment environment, ResourceLoader resourceLoader) {   this.environment = environment;   this.resourceLoader = resourceLoader == null ? new DefaultResourceLoader()     : resourceLoader;  }  public void load() {   this.propertiesLoader = new PropertySourcesLoader();   this.activatedProfiles = false;   this.profiles = Collections.asLifoQueue(new LinkedList<Profile>());   this.processedProfiles = new LinkedList<Profile>();   // Pre-existing active profiles set via Environment.setActiveProfiles()   // are additional profiles and config files are allowed to add more if   // they want to, so don't call addActiveProfiles() here.   Set<Profile> initialActiveProfiles = initializeActiveProfiles();   this.profiles.addAll(getUnprocessedActiveProfiles(initialActiveProfiles));   if (this.profiles.isEmpty()) {    for (String defaultProfileName : this.environment.getDefaultProfiles()) {     Profile defaultProfile = new Profile(defaultProfileName, true);     if (!this.profiles.contains(defaultProfile)) {      this.profiles.add(defaultProfile);     }    }   }   // The default profile for these purposes is represented as null. We add it   // last so that it is first out of the queue (active profiles will then   // override any settings in the defaults when the list is reversed later).   this.profiles.add(null);   while (!this.profiles.isEmpty()) {    Profile profile = this.profiles.poll();    for (String location : getSearchLocations()) {     if (!location.endsWith("/")) {      // location is a filename already, so don't search for more      // filenames      load(location, null, profile);     }     else {      for (String name : getSearchNames()) {       load(location, name, profile);      }     }    }    this.processedProfiles.add(profile);   }   addConfigurationProperties(this.propertiesLoader.getPropertySources());  }  private Set<Profile> initializeActiveProfiles() {   if (!this.environment.containsProperty(ACTIVE_PROFILES_PROPERTY)     && !this.environment.containsProperty(INCLUDE_PROFILES_PROPERTY)) {    return Collections.emptySet();   }   // Any pre-existing active profiles set via property sources (e.g. System   // properties) take precedence over those added in config files.   SpringProfiles springProfiles = bindSpringProfiles(     this.environment.getPropertySources());   Set<Profile> activeProfiles = new LinkedHashSet<Profile>(     springProfiles.getActiveProfiles());   activeProfiles.addAll(springProfiles.getIncludeProfiles());   maybeActivateProfiles(activeProfiles);   return activeProfiles;  }  /**   * Return the active profiles that have not been processed yet. If a profile is   * enabled via both {@link #ACTIVE_PROFILES_PROPERTY} and   * {@link ConfigurableEnvironment#addActiveProfile(String)} it needs to be   * filtered so that the {@link #ACTIVE_PROFILES_PROPERTY} value takes precedence.   * <p>   * Concretely, if the "cloud" profile is enabled via the environment, it will take   * less precedence that any profile set via the {@link #ACTIVE_PROFILES_PROPERTY}.   * @param initialActiveProfiles the profiles that have been enabled via   * {@link #ACTIVE_PROFILES_PROPERTY}   * @return the unprocessed active profiles from the environment to enable   */  private List<Profile> getUnprocessedActiveProfiles(    Set<Profile> initialActiveProfiles) {   List<Profile> unprocessedActiveProfiles = new ArrayList<Profile>();   for (String profileName : this.environment.getActiveProfiles()) {    Profile profile = new Profile(profileName);    if (!initialActiveProfiles.contains(profile)) {     unprocessedActiveProfiles.add(profile);    }   }   // Reverse them so the order is the same as from getProfilesForValue()   // (last one wins when properties are eventually resolved)   Collections.reverse(unprocessedActiveProfiles);   return unprocessedActiveProfiles;  }  private void load(String location, String name, Profile profile) {   String group = "profile=" + (profile == null ? "" : profile);   if (!StringUtils.hasText(name)) {    // Try to load directly from the location    loadIntoGroup(group, location, profile);   }   else {    // Search for a file with the given name    for (String ext : this.propertiesLoader.getAllFileExtensions()) {     if (profile != null) {      // Try the profile-specific file      loadIntoGroup(group, location + name + "-" + profile + "." + ext,        null);      for (Profile processedProfile : this.processedProfiles) {       if (processedProfile != null) {        loadIntoGroup(group, location + name + "-"          + processedProfile + "." + ext, profile);       }      }      // Sometimes people put "spring.profiles: dev" in      // application-dev.yml (gh-340). Arguably we should try and error      // out on that, but we can be kind and load it anyway.      loadIntoGroup(group, location + name + "-" + profile + "." + ext,        profile);     }     // Also try the profile-specific section (if any) of the normal file     loadIntoGroup(group, location + name + "." + ext, profile);    }   }  }  private PropertySource<?> loadIntoGroup(String identifier, String location,    Profile profile) {   try {    return doLoadIntoGroup(identifier, location, profile);   }   catch (Exception ex) {    throw new IllegalStateException(      "Failed to load property source from location '" + location + "'",      ex);   }  }  private PropertySource<?> doLoadIntoGroup(String identifier, String location,    Profile profile) throws IOException {   Resource resource = this.resourceLoader.getResource(location);   PropertySource<?> propertySource = null;   StringBuilder msg = new StringBuilder();   if (resource != null && resource.exists()) {    String name = "applicationConfig: [" + location + "]";    String group = "applicationConfig: [" + identifier + "]";    propertySource = this.propertiesLoader.load(resource, group, name,      (profile == null ? null : profile.getName()));    if (propertySource != null) {     msg.append("Loaded ");     handleProfileProperties(propertySource);    }    else {     msg.append("Skipped (empty) ");    }   }   else {    msg.append("Skipped ");   }   msg.append("config file ");   msg.append(getResourceDescription(location, resource));   if (profile != null) {    msg.append(" for profile ").append(profile);   }   if (resource == null || !resource.exists()) {    msg.append(" resource not found");    this.logger.trace(msg);   }   else {    this.logger.debug(msg);   }   return propertySource;  }  private String getResourceDescription(String location, Resource resource) {   String resourceDescription = "'" + location + "'";   if (resource != null) {    try {     resourceDescription = String.format("'%s' (%s)",       resource.getURI().toASCIIString(), location);    }    catch (IOException ex) {     // Use the location as the description    }   }   return resourceDescription;  }  private void handleProfileProperties(PropertySource<?> propertySource) {   SpringProfiles springProfiles = bindSpringProfiles(propertySource);   maybeActivateProfiles(springProfiles.getActiveProfiles());   addProfiles(springProfiles.getIncludeProfiles());  }  private SpringProfiles bindSpringProfiles(PropertySource<?> propertySource) {   MutablePropertySources propertySources = new MutablePropertySources();   propertySources.addFirst(propertySource);   return bindSpringProfiles(propertySources);  }  private SpringProfiles bindSpringProfiles(PropertySources propertySources) {   SpringProfiles springProfiles = new SpringProfiles();   RelaxedDataBinder dataBinder = new RelaxedDataBinder(springProfiles,     "spring.profiles");   dataBinder.bind(new PropertySourcesPropertyValues(propertySources, false));   springProfiles.setActive(resolvePlaceholders(springProfiles.getActive()));   springProfiles.setInclude(resolvePlaceholders(springProfiles.getInclude()));   return springProfiles;  }  private List<String> resolvePlaceholders(List<String> values) {   List<String> resolved = new ArrayList<String>();   for (String value : values) {    resolved.add(this.environment.resolvePlaceholders(value));   }   return resolved;  }  private void maybeActivateProfiles(Set<Profile> profiles) {   if (this.activatedProfiles) {    if (!profiles.isEmpty()) {     this.logger.debug("Profiles already activated, '" + profiles       + "' will not be applied");    }    return;   }   if (!profiles.isEmpty()) {    addProfiles(profiles);    this.logger.debug("Activated profiles "      + StringUtils.collectionToCommaDelimitedString(profiles));    this.activatedProfiles = true;    removeUnprocessedDefaultProfiles();   }  }  private void removeUnprocessedDefaultProfiles() {   for (Iterator<Profile> iterator = this.profiles.iterator(); iterator     .hasNext();) {    if (iterator.next().isDefaultProfile()) {     iterator.remove();    }   }  }  private void addProfiles(Set<Profile> profiles) {   for (Profile profile : profiles) {    this.profiles.add(profile);    if (!environmentHasActiveProfile(profile.getName())) {     // If it's already accepted we assume the order was set     // intentionally     prependProfile(this.environment, profile);    }   }  }  private boolean environmentHasActiveProfile(String profile) {   for (String activeProfile : this.environment.getActiveProfiles()) {    if (activeProfile.equals(profile)) {     return true;    }   }   return false;  }  private void prependProfile(ConfigurableEnvironment environment,    Profile profile) {   Set<String> profiles = new LinkedHashSet<String>();   environment.getActiveProfiles(); // ensure they are initialized   // But this one should go first (last wins in a property key clash)   profiles.add(profile.getName());   profiles.addAll(Arrays.asList(environment.getActiveProfiles()));   environment.setActiveProfiles(profiles.toArray(new String[profiles.size()]));  }  private Set<String> getSearchLocations() {   Set<String> locations = new LinkedHashSet<String>();   // User-configured settings take precedence, so we do them first   if (this.environment.containsProperty(CONFIG_LOCATION_PROPERTY)) {    for (String path : asResolvedSet(      this.environment.getProperty(CONFIG_LOCATION_PROPERTY), null)) {     if (!path.contains("$")) {      path = StringUtils.cleanPath(path);      if (!ResourceUtils.isUrl(path)) {       path = ResourceUtils.FILE_URL_PREFIX + path;      }     }     locations.add(path);    }   }   locations.addAll(     asResolvedSet(ConfigFileApplicationListener.this.searchLocations,       DEFAULT_SEARCH_LOCATIONS));   return locations;  }  private Set<String> getSearchNames() {   if (this.environment.containsProperty(CONFIG_NAME_PROPERTY)) {    return asResolvedSet(this.environment.getProperty(CONFIG_NAME_PROPERTY),      null);   }   return asResolvedSet(ConfigFileApplicationListener.this.names, DEFAULT_NAMES);  }  private Set<String> asResolvedSet(String value, String fallback) {   List<String> list = Arrays.asList(StringUtils.trimArrayElements(     StringUtils.commaDelimitedListToStringArray(value != null       ? this.environment.resolvePlaceholders(value) : fallback)));   Collections.reverse(list);   return new LinkedHashSet<String>(list);  }  private void addConfigurationProperties(MutablePropertySources sources) {   List<PropertySource<?>> reorderedSources = new ArrayList<PropertySource<?>>();   for (PropertySource<?> item : sources) {    reorderedSources.add(item);   }   addConfigurationProperties(     new ConfigurationPropertySources(reorderedSources));  }  private void addConfigurationProperties(    ConfigurationPropertySources configurationSources) {   MutablePropertySources existingSources = this.environment     .getPropertySources();   if (existingSources.contains(DEFAULT_PROPERTIES)) {    existingSources.addBefore(DEFAULT_PROPERTIES, configurationSources);   }   else {    existingSources.addLast(configurationSources);   }  } } private static class Profile {  private final String name;  private final boolean defaultProfile;  Profile(String name) {   this(name, false);  }  Profile(String name, boolean defaultProfile) {   Assert.notNull(name, "Name must not be null");   this.name = name;   this.defaultProfile = defaultProfile;  }  public String getName() {   return this.name;  }  public boolean isDefaultProfile() {   return this.defaultProfile;  }  @Override  public String toString() {   return this.name;  }  @Override  public int hashCode() {   return this.name.hashCode();  }  @Override  public boolean equals(Object obj) {   if (obj == this) {    return true;   }   if (obj == null || obj.getClass() != getClass()) {    return false;   }   return ((Profile) obj).name.equals(this.name);  } } /**  * Holds the configuration {@link PropertySource}s as they are loaded can relocate  * them once configuration classes have been processed.  */ static class ConfigurationPropertySources   extends EnumerablePropertySource<Collection<PropertySource<?>>> {  private final Collection<PropertySource<?>> sources;  private final String[] names;  ConfigurationPropertySources(Collection<PropertySource<?>> sources) {   super(APPLICATION_CONFIGURATION_PROPERTY_SOURCE_NAME, sources);   this.sources = sources;   List<String> names = new ArrayList<String>();   for (PropertySource<?> source : sources) {    if (source instanceof EnumerablePropertySource) {     names.addAll(Arrays.asList(       ((EnumerablePropertySource<?>) source).getPropertyNames()));    }   }   this.names = names.toArray(new String[names.size()]);  }  @Override  public Object getProperty(String name) {   for (PropertySource<?> propertySource : this.sources) {    Object value = propertySource.getProperty(name);    if (value != null) {     return value;    }   }   return null;  }  public static void finishAndRelocate(MutablePropertySources propertySources) {   String name = APPLICATION_CONFIGURATION_PROPERTY_SOURCE_NAME;   ConfigurationPropertySources removed = (ConfigurationPropertySources) propertySources     .get(name);   if (removed != null) {    for (PropertySource<?> propertySource : removed.sources) {     if (propertySource instanceof EnumerableCompositePropertySource) {      EnumerableCompositePropertySource composite = (EnumerableCompositePropertySource) propertySource;      for (PropertySource<?> nested : composite.getSource()) {       propertySources.addAfter(name, nested);       name = nested.getName();      }     }     else {      propertySources.addAfter(name, propertySource);     }    }    propertySources.remove(APPLICATION_CONFIGURATION_PROPERTY_SOURCE_NAME);   }  }  @Override  public String[] getPropertyNames() {   return this.names;  } } /**  * Holder for {@code spring.profiles} properties.  */ static final class SpringProfiles {  private List<String> active = new ArrayList<String>();  private List<String> include = new ArrayList<String>();  public List<String> getActive() {   return this.active;  }  public void setActive(List<String> active) {   this.active = active;  }  public List<String> getInclude() {   return this.include;  }  public void setInclude(List<String> include) {   this.include = include;  }  Set<Profile> getActiveProfiles() {   return asProfileSet(this.active);  }  Set<Profile> getIncludeProfiles() {   return asProfileSet(this.include);  }  private Set<Profile> asProfileSet(List<String> profileNames) {   List<Profile> profiles = new ArrayList<Profile>();   for (String profileName : profileNames) {    profiles.add(new Profile(profileName));   }   Collections.reverse(profiles);   return new LinkedHashSet<Profile>(profiles);  } }}

 @Override public void onApplicationEvent(ApplicationEvent event) {  if (event instanceof ApplicationEnvironmentPreparedEvent) {   onApplicationEnvironmentPreparedEvent(     (ApplicationEnvironmentPreparedEvent) event);  }  if (event instanceof ApplicationPreparedEvent) {   onApplicationPreparedEvent(event);  } }

 @Override public void postProcessEnvironment(ConfigurableEnvironment environment,   SpringApplication application) {  addPropertySources(environment, application.getResourceLoader());  configureIgnoreBeanInfo(environment);  bindToSpringApplication(environment, application); }

/**  * Bind the environment to the {@link SpringApplication}.  * @param environment the environment to bind  * @param application the application to bind to  */ protected void bindToSpringApplication(ConfigurableEnvironment environment,   SpringApplication application) {  PropertiesConfigurationFactory<SpringApplication> binder = new PropertiesConfigurationFactory<SpringApplication>(    application);  binder.setTargetName("spring.main");  binder.setConversionService(this.conversionService);  binder.setPropertySources(environment.getPropertySources());  try {   binder.bindPropertiesToTarget();  }  catch (BindException ex) {   throw new IllegalStateException("Cannot bind to SpringApplication", ex);  } }

private Map<String, Object> changes(Map<String, Object> before,   Map<String, Object> after) {  Map<String, Object> result = new HashMap<String, Object>();  for (String key : before.keySet()) {   if (!after.containsKey(key)) {    result.put(key, null);   }   else if (!equal(before.get(key), after.get(key))) {    result.put(key, after.get(key));   }  }  for (String key : after.keySet()) {   if (!before.containsKey(key)) {    result.put(key, after.get(key));   }  }  return result; }

/* * Copyright 2013-2014 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *  http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.cloud.context.properties;import java.util.HashSet;import java.util.Map;import java.util.Set;import java.util.concurrent.ConcurrentHashMap;import org.springframework.aop.framework.Advised;import org.springframework.aop.support.AopUtils;import org.springframework.beans.BeansException;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.cloud.context.config.annotation.RefreshScope;import org.springframework.cloud.context.environment.EnvironmentChangeEvent;import org.springframework.context.ApplicationContext;import org.springframework.context.ApplicationContextAware;import org.springframework.context.ApplicationListener;import org.springframework.core.env.Environment;import org.springframework.jmx.export.annotation.ManagedAttribute;import org.springframework.jmx.export.annotation.ManagedOperation;import org.springframework.jmx.export.annotation.ManagedResource;import org.springframework.stereotype.Component;/** * Listens for {@link EnvironmentChangeEvent} and rebinds beans that were bound to the * {@link Environment} using {@link ConfigurationProperties * <code>@ConfigurationProperties</code>}. When these beans are re-bound and * re-initialized the changes are available immediately to any component that is using the * <code>@ConfigurationProperties</code> bean. * * @see RefreshScope for a deeper and optionally more focused refresh of bean components * * @author Dave Syer * */@Component@ManagedResourcepublic class ConfigurationPropertiesRebinder  implements ApplicationContextAware, ApplicationListener<EnvironmentChangeEvent> { private ConfigurationPropertiesBeans beans; private ApplicationContext applicationContext; private Map<String, Exception> errors = new ConcurrentHashMap<>(); public ConfigurationPropertiesRebinder(ConfigurationPropertiesBeans beans) {  this.beans = beans; } @Override public void setApplicationContext(ApplicationContext applicationContext)   throws BeansException {  this.applicationContext = applicationContext; } /**  * A map of bean name to errors when instantiating the bean.  *  * @return the errors accumulated since the latest destroy  */ public Map<String, Exception> getErrors() {  return this.errors; } @ManagedOperation public void rebind() {  this.errors.clear();  for (String name : this.beans.getBeanNames()) {   rebind(name);  } } @ManagedOperation public boolean rebind(String name) {  if (!this.beans.getBeanNames().contains(name)) {   return false;  }  if (this.applicationContext != null) {   try {    Object bean = this.applicationContext.getBean(name);    if (AopUtils.isAopProxy(bean)) {     bean = getTargetObject(bean);    }    this.applicationContext.getAutowireCapableBeanFactory().destroyBean(bean);    this.applicationContext.getAutowireCapableBeanFactory()      .initializeBean(bean, name);    return true;   }   catch (RuntimeException e) {    this.errors.put(name, e);    throw e;   }  }  return false; } @SuppressWarnings("unchecked") private static <T> T getTargetObject(Object candidate) {  try {   if (AopUtils.isAopProxy(candidate) && (candidate instanceof Advised)) {    return (T) ((Advised) candidate).getTargetSource().getTarget();   }  }  catch (Exception ex) {   throw new IllegalStateException("Failed to unwrap proxied object", ex);  }  return (T) candidate; } @ManagedAttribute public Set<String> getBeanNames() {  return new HashSet<String>(this.beans.getBeanNames()); } @Override public void onApplicationEvent(EnvironmentChangeEvent event) {  if (this.applicationContext.equals(event.getSource())    // Backwards compatible    || event.getKeys().equals(event.getSource())) {   rebind();  } }}

/* * Copyright 2013-2014 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *  http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.cloud.logging;import java.util.Map;import java.util.Map.Entry;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.springframework.boot.bind.RelaxedPropertyResolver;import org.springframework.boot.logging.LogLevel;import org.springframework.boot.logging.LoggingSystem;import org.springframework.cloud.context.environment.EnvironmentChangeEvent;import org.springframework.context.ApplicationListener;import org.springframework.context.EnvironmentAware;import org.springframework.core.env.Environment;/** * Listener that looks for {@link EnvironmentChangeEvent} and rebinds logger levels if any * changed. * * @author Dave Syer * */public class LoggingRebinder  implements ApplicationListener<EnvironmentChangeEvent>, EnvironmentAware { private final Log logger = LogFactory.getLog(getClass()); private Environment environment; @Override public void setEnvironment(Environment environment) {  this.environment = environment; } @Override public void onApplicationEvent(EnvironmentChangeEvent event) {  if (this.environment == null) {   return;  }  LoggingSystem system = LoggingSystem.get(LoggingSystem.class.getClassLoader());  setLogLevels(system, this.environment); } protected void setLogLevels(LoggingSystem system, Environment environment) {  Map<String, Object> levels = new RelaxedPropertyResolver(environment)    .getSubProperties("logging.level.");  for (Entry<String, Object> entry : levels.entrySet()) {   setLogLevel(system, environment, entry.getKey(), entry.getValue().toString());  } } private void setLogLevel(LoggingSystem system, Environment environment, String name,   String level) {  try {   if (name.equalsIgnoreCase("root")) {    name = null;   }   level = environment.resolvePlaceholders(level);   system.setLogLevel(name, LogLevel.valueOf(level.toUpperCase()));  }  catch (RuntimeException ex) {   this.logger.error("Cannot set level: " + level + " for '" + name + "'");  } }}

/* * Copyright 2013-2014 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *  http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.cloud.context.config.annotation;import java.lang.annotation.Documented;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;import org.springframework.context.annotation.Scope;import org.springframework.context.annotation.ScopedProxyMode;/** * 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. *  * @author Dave Syer * */@Target({ ElementType.TYPE, ElementType.METHOD })@Retention(RetentionPolicy.RUNTIME)@Scope("refresh")@Documentedpublic @interface RefreshScope { /**  * @see Scope#proxyMode()  */ ScopedProxyMode proxyMode() default ScopedProxyMode.TARGET_CLASS;}

/* * Copyright 2002-2009 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. */package org.springframework.cloud.context.scope.refresh;import java.io.Serializable;import org.springframework.beans.BeansException;import org.springframework.beans.factory.config.BeanDefinition;import org.springframework.beans.factory.support.BeanDefinitionRegistry;import org.springframework.cloud.context.scope.GenericScope;import org.springframework.context.ApplicationContext;import org.springframework.context.ApplicationContextAware;import org.springframework.context.event.ContextRefreshedEvent;import org.springframework.context.event.EventListener;import org.springframework.core.Ordered;import org.springframework.jmx.export.annotation.ManagedOperation;import org.springframework.jmx.export.annotation.ManagedResource;/** * <p> * A Scope implementation that allows for beans to be refreshed dynamically at runtime * (see {@link #refresh(String)} and {@link #refreshAll()}). If a bean is refreshed then * the next time the bean is accessed (i.e. a method is executed) a new instance is * created. All lifecycle methods are applied to the bean instances, so any destruction * callbacks that were registered in the bean factory are called when it is refreshed, and * then the initialization callbacks are invoked as normal when the new instance is * created. A new bean instance is created from the original bean definition, so any * externalized content (property placeholders or expressions in string literals) is * re-evaluated when it is created. * </p> * * <p> * Note that all beans in this scope are <em>only</em> initialized when first accessed, so * the scope forces lazy initialization semantics. The implementation involves creating a * proxy for every bean in the scope, so there is a flag * {@link #setProxyTargetClass(boolean) proxyTargetClass} which controls the proxy * creation, defaulting to JDK dynamic proxies and therefore only exposing the interfaces * implemented by a bean. If callers need access to other methods then the flag needs to * be set (and CGLib present on the classpath). Because this scope automatically proxies * all its beans, there is no need to add <code><aop:auto-proxy/></code> to any bean * definitions. * </p> * * <p> * The scoped proxy approach adopted here has a side benefit that bean instances are * automatically {@link Serializable}, and can be sent across the wire as long as the * receiver has an identical application context on the other side. To ensure that the two * contexts agree that they are identical they have to have the same serialization id. One * will be generated automatically by default from the bean names, so two contexts with * the same bean names are by default able to exchange beans by name. If you need to * override the default id then provide an explicit {@link #setId(String) id} when the * Scope is declared. * </p> * * @author Dave Syer * * @since 3.1 * */@ManagedResourcepublic class RefreshScope extends GenericScope  implements ApplicationContextAware, Ordered { private ApplicationContext context; private BeanDefinitionRegistry registry; private boolean eager = true; private int order = Ordered.LOWEST_PRECEDENCE - 100; /**  * Create a scope instance and give it the default name: "refresh".  */ public RefreshScope() {  super.setName("refresh"); } @Override public int getOrder() {  return this.order; } public void setOrder(int order) {  this.order = order; } /**  * Flag to determine whether all beans in refresh scope should be instantiated eagerly  * on startup. Default true.  *  * @param eager the flag to set  */ public void setEager(boolean eager) {  this.eager = eager; } @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)   throws BeansException {  this.registry = registry;  super.postProcessBeanDefinitionRegistry(registry); } @EventListener public void start(ContextRefreshedEvent event) {  if (event.getApplicationContext() == this.context && this.eager    && this.registry != null) {   eagerlyInitialize();  } } private void eagerlyInitialize() {  for (String name : this.context.getBeanDefinitionNames()) {   BeanDefinition definition = this.registry.getBeanDefinition(name);   if (this.getName().equals(definition.getScope()) && !definition.isLazyInit()) {    Object bean = this.context.getBean(name);    if (bean != null) {     bean.getClass();    }   }  } } @ManagedOperation(description = "Dispose of the current instance of bean name provided and force a refresh on next method execution.") public boolean refresh(String name) {  if (!name.startsWith(SCOPED_TARGET_PREFIX)) {   // User wants to refresh the bean with this name but that isn't the one in the   // cache...   name = SCOPED_TARGET_PREFIX + name;  }  // Ensure lifecycle is finished if bean was disposable  if (super.destroy(name)) {   this.context.publishEvent(new RefreshScopeRefreshedEvent(name));   return true;  }  return false; } @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()); } @Override public void setApplicationContext(ApplicationContext context) throws BeansException {  this.context = context; }}

/* * Copyright 2002-2009 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. */package org.springframework.cloud.context.scope;import java.lang.reflect.Method;import java.util.ArrayList;import java.util.Arrays;import java.util.Collection;import java.util.Collections;import java.util.LinkedHashSet;import java.util.List;import java.util.Map;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ConcurrentMap;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReadWriteLock;import java.util.concurrent.locks.ReentrantReadWriteLock;import org.aopalliance.intercept.MethodInterceptor;import org.aopalliance.intercept.MethodInvocation;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.springframework.aop.framework.Advised;import org.springframework.aop.scope.ScopedObject;import org.springframework.aop.scope.ScopedProxyFactoryBean;import org.springframework.aop.support.AopUtils;import org.springframework.beans.BeansException;import org.springframework.beans.factory.BeanFactory;import org.springframework.beans.factory.DisposableBean;import org.springframework.beans.factory.ObjectFactory;import org.springframework.beans.factory.config.BeanDefinition;import org.springframework.beans.factory.config.BeanFactoryPostProcessor;import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;import org.springframework.beans.factory.config.Scope;import org.springframework.beans.factory.support.BeanDefinitionRegistry;import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;import org.springframework.beans.factory.support.DefaultListableBeanFactory;import org.springframework.beans.factory.support.RootBeanDefinition;import org.springframework.expression.Expression;import org.springframework.expression.ExpressionParser;import org.springframework.expression.ParseException;import org.springframework.expression.spel.standard.SpelExpressionParser;import org.springframework.expression.spel.support.StandardEvaluationContext;import org.springframework.util.ReflectionUtils;import org.springframework.util.StringUtils;/** * <p> * A generic Scope implementation. * </p> * * @author Dave Syer * * @since 3.1 * */public class GenericScope implements Scope, BeanFactoryPostProcessor,  BeanDefinitionRegistryPostProcessor, DisposableBean { private static final Log logger = LogFactory.getLog(GenericScope.class); public static final String SCOPED_TARGET_PREFIX = "scopedTarget."; private BeanLifecycleWrapperCache cache = new BeanLifecycleWrapperCache(   new StandardScopeCache()); private String name = "generic"; private ConfigurableListableBeanFactory beanFactory; private StandardEvaluationContext evaluationContext; private String id; private Map<String, Exception> errors = new ConcurrentHashMap<>(); private ConcurrentMap<String, ReadWriteLock> locks = new ConcurrentHashMap<>(); /**  * Manual override for the serialization id that will be used to identify the bean  * factory. The default is a unique key based on the bean names in the bean factory.  *  * @param id the id to set  */ public void setId(String id) {  this.id = id; } /**  * The name of this scope. Default "generic".  *  * @param name the name value to set  */ public void setName(String name) {  this.name = name; } /**  * The cache implementation to use for bean instances in this scope.  *  * @param cache the cache to use  */ public void setScopeCache(ScopeCache cache) {  this.cache = new BeanLifecycleWrapperCache(cache); } /**  * A map of bean name to errors when instantiating the bean.  *  * @return the errors accumulated since the latest destroy  */ public Map<String, Exception> getErrors() {  return this.errors; } @Override public void destroy() {  List<Throwable> errors = new ArrayList<Throwable>();  Collection<BeanLifecycleWrapper> wrappers = this.cache.clear();  for (BeanLifecycleWrapper wrapper : wrappers) {   try {    Lock lock = 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(); } /**  * Destroy the named bean (i.e. flush it from the cache by default).  *  * @param name the bean name to flush  * @return true if the bean was already cached, false otherwise  */ protected boolean destroy(String name) {  BeanLifecycleWrapper wrapper = this.cache.remove(name);  if (wrapper != null) {   Lock lock = locks.get(wrapper.getName()).writeLock();   lock.lock();   try {    wrapper.destroy();   }   finally {    lock.unlock();   }   this.errors.remove(name);   return true;  }  return false; } @Override public Object get(String name, ObjectFactory<?> objectFactory) {  BeanLifecycleWrapper value = this.cache.put(name,    new BeanLifecycleWrapper(name, objectFactory));  locks.putIfAbsent(name, new ReentrantReadWriteLock());  try {   return value.getBean();  }  catch (RuntimeException e) {   this.errors.put(name, e);   throw e;  } } @Override public String getConversationId() {  return this.name; } @Override public void registerDestructionCallback(String name, Runnable callback) {  BeanLifecycleWrapper value = this.cache.get(name);  if (value == null) {   return;  }  value.setDestroyCallback(callback); } @Override public Object remove(String name) {  BeanLifecycleWrapper value = this.cache.remove(name);  if (value == null) {   return null;  }  // Someone might have added another object with the same key, but we  // keep the method contract by removing the  // value we found anyway  return value.getBean(); } @Override public Object resolveContextualObject(String key) {  Expression expression = parseExpression(key);  return expression.getValue(this.evaluationContext, this.beanFactory); } private Expression parseExpression(String input) {  if (StringUtils.hasText(input)) {   ExpressionParser parser = new SpelExpressionParser();   try {    return parser.parseExpression(input);   }   catch (ParseException e) {    throw new IllegalArgumentException("Cannot parse expression: " + input,      e);   }  }  else {   return null;  } } @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)   throws BeansException {  this.beanFactory = beanFactory;  beanFactory.registerScope(this.name, this);  setSerializationId(beanFactory); } @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)   throws BeansException {  for (String name : registry.getBeanDefinitionNames()) {   BeanDefinition definition = registry.getBeanDefinition(name);   if (definition instanceof RootBeanDefinition) {    RootBeanDefinition root = (RootBeanDefinition) definition;    if (root.getDecoratedDefinition() != null && root.hasBeanClass()      && root.getBeanClass() == ScopedProxyFactoryBean.class) {     if (getName().equals(root.getDecoratedDefinition().getBeanDefinition()       .getScope())) {      root.setBeanClass(LockedScopedProxyFactoryBean.class);     }    }   }  } } /**  * If the bean factory is a DefaultListableBeanFactory then it can serialize scoped  * beans and deserialize them in another context (even in another JVM), as long as the  * ids of the bean factories match. This method sets up the serialization id to be  * either the id provided to the scope instance, or if that is null, a hash of all the  * bean names.  *  * @param beanFactory the bean factory to configure  */ private void setSerializationId(ConfigurableListableBeanFactory beanFactory) {  if (beanFactory instanceof DefaultListableBeanFactory) {   String id = this.id;   if (id == null) {    List<String> list = new ArrayList<>(      Arrays.asList(beanFactory.getBeanDefinitionNames()));    Collections.sort(list);    String names = list.toString();    logger.debug("Generating bean factory id from names: " + names);    id = UUID.nameUUIDFromBytes(names.getBytes()).toString();   }   logger.info("BeanFactory id=" + id);   ((DefaultListableBeanFactory) beanFactory).setSerializationId(id);  }  else {   logger.warn(     "BeanFactory was not a DefaultListableBeanFactory, scoped proxy beans "       + "cannot be serialized.");  } } static RuntimeException wrapIfNecessary(Throwable throwable) {  if (throwable instanceof RuntimeException) {   return (RuntimeException) throwable;  }  if (throwable instanceof Error) {   throw (Error) throwable;  }  return new IllegalStateException(throwable); } protected String getName() {  return this.name; } private static class BeanLifecycleWrapperCache {  private final ScopeCache cache;  public BeanLifecycleWrapperCache(ScopeCache cache) {   this.cache = cache;  }  public BeanLifecycleWrapper remove(String name) {   return (BeanLifecycleWrapper) this.cache.remove(name);  }  public Collection<BeanLifecycleWrapper> clear() {   Collection<Object> values = this.cache.clear();   Collection<BeanLifecycleWrapper> wrappers = new LinkedHashSet<BeanLifecycleWrapper>();   for (Object object : values) {    wrappers.add((BeanLifecycleWrapper) object);   }   return wrappers;  }  public BeanLifecycleWrapper get(String name) {   return (BeanLifecycleWrapper) this.cache.get(name);  }  public BeanLifecycleWrapper put(String name, BeanLifecycleWrapper value) {   return (BeanLifecycleWrapper) this.cache.put(name, value);  } } /**  * Wrapper for a bean instance and any destruction callback (DisposableBean etc.) that  * is registered for it. Also decorates the bean to optionally guard it from  * concurrent access (for instance).  *  * @author Dave Syer  *  */ private static class BeanLifecycleWrapper {  private Object bean;  private Runnable callback;  private final String name;  private final ObjectFactory<?> objectFactory;  public BeanLifecycleWrapper(String name, ObjectFactory<?> objectFactory) {   this.name = name;   this.objectFactory = objectFactory;  }  public String getName() {   return this.name;  }  public void setDestroyCallback(Runnable callback) {   this.callback = callback;  }  public Object getBean() {   if (this.bean == null) {    synchronized (this.name) {     if (this.bean == null) {      this.bean = this.objectFactory.getObject();     }    }   }   return this.bean;  }  public void destroy() {   if (this.callback == null) {    return;   }   synchronized (this.name) {    Runnable callback = this.callback;    if (callback != null) {     callback.run();    }    this.callback = null;    this.bean = null;   }  }  @Override  public int hashCode() {   final int prime = 31;   int result = 1;   result = prime * result + ((this.name == null) ? 0 : this.name.hashCode());   return result;  }  @Override  public boolean equals(Object obj) {   if (this == obj) {    return true;   }   if (obj == null) {    return false;   }   if (getClass() != obj.getClass()) {    return false;   }   BeanLifecycleWrapper other = (BeanLifecycleWrapper) obj;   if (this.name == null) {    if (other.name != null) {     return false;    }   }   else if (!this.name.equals(other.name)) {    return false;   }   return true;  } } @SuppressWarnings("serial") public class LockedScopedProxyFactoryBean extends ScopedProxyFactoryBean   implements MethodInterceptor {  private String targetBeanName;  @Override  public void setBeanFactory(BeanFactory beanFactory) {   super.setBeanFactory(beanFactory);   Object proxy = getObject();   if (proxy instanceof Advised) {    Advised advised = (Advised) proxy;    advised.addAdvice(0, this);   }  }  @Override  public void setTargetBeanName(String targetBeanName) {   super.setTargetBeanName(targetBeanName);   this.targetBeanName = targetBeanName;  }  @Override  public Object invoke(MethodInvocation invocation) throws Throwable {   Method method = invocation.getMethod();   if (AopUtils.isEqualsMethod(method)     || AopUtils.isToStringMethod(method)     || AopUtils.isHashCodeMethod(method)     || isScopedObjectGetTargetObject(method)) {    return invocation.proceed();   }   Object proxy = getObject();   Lock lock = locks.get(this.targetBeanName).readLock();   lock.lock();   try {    if (proxy instanceof Advised) {     Advised advised = (Advised) proxy;     ReflectionUtils.makeAccessible(method);     return ReflectionUtils.invokeMethod(method,       advised.getTargetSource().getTarget(),       invocation.getArguments());    }    return invocation.proceed();   }   finally {    lock.unlock();   }  }  private boolean isScopedObjectGetTargetObject(Method method) {   return method.getDeclaringClass().equals(ScopedObject.class)     && method.getName().equals("getTargetObject")     && method.getParameterTypes().length == 0;  } }}

/**  * Create a scope instance and give it the default name: "refresh".  */ public RefreshScope() {  super.setName("refresh"); }

 @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)   throws BeansException {  this.beanFactory = beanFactory;  beanFactory.registerScope(this.name, this);  setSerializationId(beanFactory); }

@Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)   throws BeansException {  for (String name : registry.getBeanDefinitionNames()) {   BeanDefinition definition = registry.getBeanDefinition(name);   if (definition instanceof RootBeanDefinition) {    RootBeanDefinition root = (RootBeanDefinition) definition;    if (root.getDecoratedDefinition() != null && root.hasBeanClass()      && root.getBeanClass() == ScopedProxyFactoryBean.class) {     if (getName().equals(root.getDecoratedDefinition().getBeanDefinition()       .getScope())) {      root.setBeanClass(LockedScopedProxyFactoryBean.class);     }    }   }  } }

@EventListener public void start(ContextRefreshedEvent event) {  if (event.getApplicationContext() == this.context && this.eager    && this.registry != null) {   eagerlyInitialize();  } } private void eagerlyInitialize() {  for (String name : this.context.getBeanDefinitionNames()) {   BeanDefinition definition = this.registry.getBeanDefinition(name);   if (this.getName().equals(definition.getScope()) && !definition.isLazyInit()) {    Object bean = this.context.getBean(name);    if (bean != null) {     bean.getClass();    }   }  } }

 @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()); }//.......GernericScope的destroy方法 @Override public void destroy() {  List<Throwable> errors = new ArrayList<Throwable>();  Collection<BeanLifecycleWrapper> wrappers = this.cache.clear();  for (BeanLifecycleWrapper wrapper : wrappers) {   try {    Lock lock = 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(); }

@Override public Object get(String name, ObjectFactory<?> objectFactory) {  BeanLifecycleWrapper value = this.cache.put(name,    new BeanLifecycleWrapper(name, objectFactory));  locks.putIfAbsent(name, new ReentrantReadWriteLock());  try {   return value.getBean();  }  catch (RuntimeException e) {   this.errors.put(name, e);   throw e;  } }  //..... BeanLifecycleWrapper的方法  public Object getBean() {   if (this.bean == null) {    synchronized (this.name) {     if (this.bean == null) {      this.bean = this.objectFactory.getObject();     }    }   }   return this.bean;  }   

package com.bdqn.lyrk.refresh.scope.server;import org.springframework.boot.context.properties.EnableConfigurationProperties;import org.springframework.cloud.context.config.annotation.RefreshScope;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;@Configuration@EnableConfigurationProperties(StudentConfig.class)public class AppConfig { @RefreshScope @Bean public Student student(StudentConfig config) {  Student student = new Student();  student.setName(config.getName());  return student; }}

package com.bdqn.lyrk.refresh.scope.server;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;@SpringBootApplication@RestControllerpublic class RefreshScopeApplication { @Autowired private Student student; @GetMapping public String student() {  return student.getName(); } public static void main(String[] args) throws InterruptedException {  SpringApplication.run(RefreshScopeApplication.class, args); }}

spring: application: name: refresh-scope-serverendpoints: refresh: sensitive: falseserver: port: 8089student: name: admin