SpringCloud配置刷新原理解析

我们知道在SpringCloud中,当配置变更时,我们通过访问http://xxxx/refresh,可以在不启动服务的情况下获取最新的配置,那么它是如何做到的呢,当我们更改数据库配置并刷新后,如何能获取最新的数据源对象呢?下面我们看SpringCloud如何做到的。

一、环境变化

1.1、关于ContextRefresher

  当我们访问/refresh时,会被RefreshEndpoint类所处理。我们来看源代码:

/*
 * 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)
@ManagedResource
public 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());
 }
}

  通过源代码我们了解到:当访问refresh端点时,实际上执行的是ContextRefresher的refresh方法,那么我们继续追踪源代码,找到其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;
 }

  我们可以看到refresh方法做了如下几件事情:

  1)获取刷新之前的所有PropertySource

  2) 调用addConfigFilesToEnvironment方法获取最新的配置

  3) 调用changes方法更新配置信息

  4) 发布EnvironmentChangeEnvent事件

  5)调用refreshScope的refreshAll方法刷新范围

  我们重点关注一下2,3,4步骤

1.2、addConfigFilesToEnvironment方法

  我们先来看看这个方法是怎么实现的:

/* 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;
 }

  1) 该方法首先拷贝当前的Environment

  2) 通过SpringApplicationBuilder构建了一个简单的SpringBoot启动程序并启动

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

  这里面会添加两个监听器分别为:BootstrapApplicationListener与ConfigFileApplicationListener,通过先前的学习,我们知道BootstrapApplicationListener是引导程序的核心监听器,而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);
  }
 }
}

  根据javadoc注释的说明,这个类会从指定的位置加载application.properties或者application.yml并将它们的属性读到Envrionment当中,其中这几个方法大家关注下:

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

  当springboot程序启动时一定会触发该事件监听,如果当前是 ApplicationEnvironmentPreparedEvent事件就会调用 onApplicationEnvironmentPreparedEvent方法,最终该方法会执行:

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

   其中 bindToSpringApplication方法为:

/**
  * 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);
  }
 }

  很明显该方法是将Environment绑定到对应SpringApplication上,通过这个类就可以获取到我们更改过后的配置了

1.3、changes方法

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

  changes方法其实就是处理配置变更信息的,分以下几种情况:

  1)如果刷新过后配置文件新增配置就添加到Map里

  2)  如果有配置变更就添加变更后的配置

  3) 如果删除了原先的配置,就把原先的key对应的值设置为null

  至此经过changes方法后,上下文环境已经拥有最新的配置了。

1.4、发布事件

  当上述步骤都执行完毕后,紧接着会发布EnvrionmentChangeEvent事件,可是这个事件谁来监听呢?在这里我贴出官网的一段描述:

   应用程序将收听EnvironmentChangeEvent,并以几种标准方式进行更改(用户可以以常规方式添加ApplicationListeners附加ApplicationListeners)。当观察到EnvironmentChangeEvent时,它将有一个已更改的键值列表,应用程序将使用以下内容:

1.重新绑定上下文中的任何@ConfigurationProperties bean

2.为logging.level.*中的任何属性设置记录器级别

  根据官网描述我们知道将变更一下操作行为@ConfigurationProperties的bean与更改日志level,那么如何做到的呢?结合官网文档我们来关注以下两个类:

  ConfigurationPropertiesRebinder:

/*
 * 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
@ManagedResource
public 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();
  }
 }
}

  我们可以看到该类监听了ChangeEnvrionmentEvent事件,它最主要作用是拿到更新的配置以后,重新绑定@ConfigurationProperties标记的类使之能够读取最新的属性

  LoggingRebinder:

/*
 * 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 + "'");
  }
 }
}

  该类也是监听了ChangeEnvrionmentEvent事件,用于重新绑定日志级别

二、刷新范围

  我们考虑如下场景,当我们变更数据库配置后,通过refresh刷新,虽然能获取到最新的配置,可是我们的DataSource对象早就被初始化好了,换句话说即便配置刷新了我们拿到的依然是配置刷新前的对象。怎么解决这个问题呢?

  我们继续看ContextRefresher的refresh方法,最后有一处代码值得我们关注一下this.scope.refreshAll(),此处scope对象是RefreshScope类型,那么这个类有什么作用呢?那么我们先要关注一下@RefreshScope注解。在这里我在贴出官网一段解释:

  当配置更改时,标有@RefreshScope的Spring @Bean将得到特殊处理。这解决了状态bean在初始化时只注入配置的问题。例如,如果通过Environment更改数据库URL时DataSource有开放连接,那么我们可能希望这些连接的持有人能够完成他们正在做的工作。然后下一次有人从游泳池借用一个连接,他得到一个新的URL
  
   刷新范围bean是在使用时初始化的懒惰代理(即当调用一个方法时),并且作用域作为初始值的缓存。要强制bean重新初始化下一个方法调用,您只需要使其缓存条目无效。RefreshScope是上下文中的一个bean,它有一个公共方法refreshAll()来清除目标缓存中的范围内的所有bean。还有一个refresh(String)方法可以按名称刷新单个bean。此功能在/refresh端点(通过HTTP或JMX)中公开。

  这里我贴出@RefreshScope源码:

/*
 * 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")
@Documented
public @interface RefreshScope {
 /**
  * @see Scope#proxyMode()
  */
 ScopedProxyMode proxyMode() default ScopedProxyMode.TARGET_CLASS;
}

  在这个注解上我们关注一下此处标记了@Scope("refresh"),我们知道Spring的Bean属性有个叫scope的,它定义了bean的作用范围,常见的有singleon,prototype,session等。此处新定义了一个范围叫做refresh,在此我贴出RefreshScope的源代码来分析一下:

/*
 * 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
 *
 */
@ManagedResource
public 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;
 }
}

  该类继承了GenericScope:

/*
 * 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;
  }
 }
}

这里面我们先看一下RefreshScope的构造函数:

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

  这里面创建了一个名字为refresh的scope。

  紧接着在它的父类里我们可以看一下这个方法:

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

  此方法中使用BeanFactory注册了一个refresh的范围,使得scope为refresh的bean生效。@RefreshScope标注的类还有一个特点:会使用代理对象并进行延迟加载。我们来看一下postProcessBeanDefinitionRegistry方法

@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);
     }
    }
   }
  }
 }

  该方法遍历所有的bean定义 如果当前的bean的scope为refresh,那么就把当前的bean设置为 LockedScopedProxyFactoryBean的代理对象。

  RefreshScope还会监听一个ContextRefreshedEvent,该事件会在ApplicationContext初始化或者refreshed时触发,我们来看一下代码:

@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();
    }
   }
  }
 }

  注意此处获取refreshscope的bean,其中getBean是一个复杂而又繁琐的过程,此处我们先不在这里讨论,只不过经过这个方法以后,其通过代理机制会在GernericScope的BeanLifecycleWrapperCache缓存里把这个@RefreshScope标记的bean添加进去。

  最后我们回过头来看一看RefreshScope的refreshAll方法:

 @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();
 }

  这里的代码逻辑很简单清除与释放缓存里被@RefreshScope标记的bean 。

  当我们要获取对象时,我们可以关注如下方法:

@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;
  }   

BeanLifecycleWrapper这个是@RefreshScope标记bean的一个包装类,会被存储到缓存里,在这里取不到值的话就会从objectFactory里去拿

三、示例与总结

3.1、示例

  创建AppConfig类代码如下:

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

  在这里,将Student设置为@RefreshScope 那么刷新以后会获取最新的Bean

  启动类:

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
@RestController
public 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);
 }
}

  application.yml文件:

spring:
 application:
 name: refresh-scope-server
endpoints:
 refresh:
 sensitive: false
server:
 port: 8089
student:
 name: admin

  这里把refresh端点开放出来,然后变更配置后就可以获取最新的对象了

3.2、总结

  1) 当配置更新并通过refresh端点刷新后,会执行ContextRefresher的refresh方法,该方法会记录当前的Environment,而后构建一个简易的SpringApplicationBuilder并执行其run方法,此时ConfigFileApplicationListener会读取我们修改过后的配置并绑定到SpringApplication对象上,最后进行changes操作来变更已有的PropertySource

  2) @RefreshScope最好配合@Bean使用,当且仅当变更配置后,需要重新获取最新的bean时使用。加上该注解的Bean会被代理并且延迟加载,所有的scope属性为Refresh的bean会被包装成BeanLifecycleWrapper存入缓存(ConcurrentHashMap)中,所有的读取,修改,删除都是基于该缓存的。

总结

以上所述是小编给大家介绍的SpringCloud配置刷新原理解析,希望对大家有所帮助,如果大家有任何疑问欢迎给我留言,小编会及时回复大家的!

(0)

相关推荐

  • 详解基于Spring Cloud几行配置完成单点登录开发

    单点登录概念 单点登录(Single Sign On),简称为 SSO,是目前比较流行的企业业务整合的解决方案之一.SSO的定义是在多个应用系统中,用户只需要登录一次就可以访问所有相互信任的应用系统.登录逻辑如上图 基于Spring 全家桶的实现 技术选型: Spring Boot Spring Cloud Spring Security oAuth2 客户端: maven依赖 <dependency> <groupId>org.springframework.boot</g

  • 详解Spring Cloud Zuul中路由配置细节

    上篇文章我们介绍了API网关的基本构建方式以及请求过滤,小伙伴们对Zuul的作用应该已经有了一个基本的认识,但是对于路由的配置我们只是做了一个简单的介绍,本文我们就来看看路由配置的其他一些细节. 首先我们来回忆一下上篇文章我们配置路由规则的那两行代码: zuul.routes.api-a.path=/api-a/** zuul.routes.api-a.serviceId=feign-consumer 我们说当我的访问地址符合/api-a/**规则的时候,会被自动定位到feign-consume

  • spring cloud如何修复zuul跨域配置异常的问题

    前言 本文主要给大家介绍一下在zuul进行跨域配置的时候出现异常该如何解决的方法,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. 异常 The 'Access-Control-Allow-Origin' header contains multiple values '*, *', but only one is allowed 实例 Access-Control-Allow-Credentials:true Access-Control-Allow-Credentials:t

  • 详解Spring Cloud Eureka多网卡配置总结

    在linux主机部署Eureka高可用方案的时候,发现注册到服务中心的服务IP是随机的,由于主机的网卡是多个,随机的IP并不是自己想要的,上网查了一些资料,总结如下: 1 忽略网卡:spring.cloud.inetutils.ignored-interfaces #忽略eth0, 支持正则表达式 spring.cloud.inetutils.ignored-interfaces[0]=eth0 2 指定IP:spring.cloud.inetutils.preferred-networks #

  • spring cloud学习入门之config配置教程

    前言 本文主要给大家分享了关于spring cloud的入门教程,主要介绍了config配置的相关内容,下面话不多说了,来一起看看看详细的介绍吧. 简介 Spring cloud config 分为两部分 server client config-server 配置服务端,服务管理配置信息 config-client 客户端,客户端调用server端暴露接口获取配置信息 config-server 创建config-server 首先创建config-server工程. 文件结构: ├── co

  • SpringCloud配置刷新原理解析

    我们知道在SpringCloud中,当配置变更时,我们通过访问http://xxxx/refresh,可以在不启动服务的情况下获取最新的配置,那么它是如何做到的呢,当我们更改数据库配置并刷新后,如何能获取最新的数据源对象呢?下面我们看SpringCloud如何做到的. 一.环境变化 1.1.关于ContextRefresher 当我们访问/refresh时,会被RefreshEndpoint类所处理.我们来看源代码: /* * Copyright 2013-2014 the original a

  • SpringBoot扩展外部化配置的原理解析

    Environment实现原理 在基于SpringBoot开发的应用中,我们常常会在application.properties.application-xxx.properties.application.yml.application-xxx.yml等配置文件中设置一些属性值,然后通过@Value.@ConfigurationProperties等注解获取,或者采用编码的方式通过Environment获取. # application.properties my.config.appId=d

  • Springboot自动加载配置的原理解析

    目录 1.springboot自动配置的原理初探 2. 补充扩展(解释为什么引用的包都报红错了,项目还能启动) 3.又一个问题 总结 1.springboot自动配置的原理初探 以下注解都在springboot的自动化配置包中:spring-boot-autoconfigure.读者朋友可以跟着一下步骤走一遍,应该对自动配置就有一定的认知了. 1.springboot程序的入口是在启动类,该类有个关键注解SpringBootApplication @Target(ElementType.TYPE

  • SpringCloud Gateway 路由配置定位原理分析

    环境:springcloud Hoxton.SR11 本节主要了解系统中的谓词与配置的路由信息是如何进行初始化关联生成路由对象的.每个谓词工厂中的Config对象又是如何被解析配置的. 所有的谓词工厂中的Config中属性值是如何被配置的. 在SpringCloud Gateway中的所有谓词工厂如下: 命名规则:XxxRoutePredicateFactory.所有的这些谓词工厂都是如下的继承关系 public class MethodRoutePredicateFactory extends

  • Springboot启动原理和自动配置原理解析

    目录 启动原理 SpringApplication 1.初始化 2.调用run方法 自动配置原理 放本地文件夹都快吃土了,准备清理文件夹,关于Springboot的! 启动原理 @SpringBootApplication public class Start { public static void main(String[] args) { SpringApplication.run(Start.class, args); } } SpringApplication 1.初始化 public

  • Android ListView 单条刷新方法实践及原理解析

    对于使用listView配合adapter进行刷新的方法大家都不陌生,先刷新adapter里的数据,然后调用notifydatasetchange通知listView刷新界面. 方法虽然简单,但这里面涉及到一个效率的问题,调用notifydatasetchange其实会导致adpter的getView方法被多次调用 (画面上能显示多少就会被调用多少次),如果是很明确的知道只更新了list中的某一个项的数据(比如用户点击list某一项后更新该项的显示状态,或者 后台回调更新list某一项,等等),

  • SpringCloud Eureka自我保护机制原理解析

    这篇文章主要介绍了SpringCloud Eureka自我保护机制原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1. 自我保护机制演示 eureka在频繁修改微服务名称的时候,可以会出现如下现象: 2. 什么是自我保护模式? 默认情况下,如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳,EurekaServer将会注销该实例(默认90秒).但是当网络分区故障发生时,微服务与EurekaServer之间无法正常通信

  • SpringCloud断路器Hystrix原理及用法解析

    这篇文章主要介绍了SpringCloud断路器Hystrix原理及用法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 在分布式环境中,许多服务依赖项中的一些必然会失败.Hystrix是一个库,通过添加延迟容忍和容错逻辑,帮助你控制这些分布式服务之间的交互.Hystrix通过隔离服务之间的访问点.停止级联失败和提供回退选项来实现这一点,所有这些都可以提高系统的整体弹性 两个比较重要的类 HystrixCommand HystrixObserv

  • SpringCloud Bus如何实现配置刷新

    要想实现配置刷新,首先得有项目基础结构 项目一: 注册中心 项目二: 配置中心 项目三: 客户端 先启动注册中心 然后启动配置中心 然后在不同端口启动客户端的多个实例,这些实例都是通过bootstrap.properties连接到配置中心后,加载相应配置后启动的. 成功完成上述基础设施,才开始关注配置刷新. ========================================================================================== Spri

  • springboot自动配置原理解析

    前言 小伙伴们都知道,现在市面上最流行的web开发框架就是springboot了,在springboot开始流行之前,我们都用的是strust2或者是springmvc框架来开发web应用,但是这两个框架都有一个特点就是配置非常的繁琐,要写一大堆的配置文件,spring在支持了注解开发之后稍微有些改观但有的时候还是会觉得比较麻烦,这个时候springboot就体现出了它的优势,springboot只需要一个properties或者yml文件就可以简化springmvc中在xml中需要配置的一大堆

随机推荐