hope is coming

```Java
/**
	 * Name of property to set to specify active profiles: {@value}. Value may be comma
	 * delimited.
	 * <p>Note that certain shell environments such as Bash disallow the use of the period
	 * character in variable names. Assuming that Spring's {@link SystemEnvironmentPropertySource}
	 * is in use, this property may be specified as an environment variable as
	 * {@code SPRING_PROFILES_ACTIVE}.
	 * @see ConfigurableEnvironment#setActiveProfiles
	 */
	public static final String ACTIVE_PROFILES_PROPERTY_NAME = "spring.profiles.active";

	/**
	 * Name of property to set to specify profiles active by default: {@value}. Value may
	 * be comma delimited.
	 * <p>Note that certain shell environments such as Bash disallow the use of the period
	 * character in variable names. Assuming that Spring's {@link SystemEnvironmentPropertySource}
	 * is in use, this property may be specified as an environment variable as
	 * {@code SPRING_PROFILES_DEFAULT}.
	 * @see ConfigurableEnvironment#setDefaultProfiles
	 */
	public static final String DEFAULT_PROFILES_PROPERTY_NAME = "spring.profiles.default";

那么这个类里就包含了对我们这些配置的读写操作。参考网上的说法：

如果当spring.profiles.active属性被设置时，那么Spring会优先使用该属性对应值来激活Profile。当spring.profiles.active没有被设置时，那么Spring会根据spring.profiles.default属性的对应值来进行Profile进行激活。如果上面的两个属性都没有被设置，那么就不会有任务Profile被激活，只有定义在Profile之外的Bean才会被创建。

我们先看对默认配置的读写操作：

### setDefaultProfiles

```Java
    /**
    * Specify the set of profiles to be made active by default if no other profiles
    * are explicitly made active through {@link #setActiveProfiles}.
    * <p>Calling this method removes overrides any reserved default profiles
    * that may have been added during construction of the environment.
    * @see #AbstractEnvironment()
    * @see #getReservedDefaultProfiles()
    */
    //https://blog.csdn.net/jamet/article/details/77508182
    @Override
    public void setDefaultProfiles(String... profiles) {
    Assert.notNull(profiles, "Profile array must not be null");
      synchronized (this.defaultProfiles) {
        this.defaultProfiles.clear();
        for (String profile : profiles) {
          validateProfile(profile);
          this.defaultProfiles.add(profile);
        }
      }
    }

      /**
  	 * Validate the given profile, called internally prior to adding to the set of
  	 * active or default profiles.
  	 * <p>Subclasses may override to impose further restrictions on profile syntax.
  	 * @throws IllegalArgumentException if the profile is null, empty, whitespace-only or
  	 * begins with the profile NOT operator (!).
  	 * @see #acceptsProfiles
  	 * @see #addActiveProfile
  	 * @see #setDefaultProfiles
  	 */
  	protected void validateProfile(String profile) {
  		if (!StringUtils.hasText(profile)) {
  			throw new IllegalArgumentException("Invalid profile [" + profile + "]: must contain text");
  		}
  		if (profile.charAt(0) == '!') {
  			throw new IllegalArgumentException("Invalid profile [" + profile + "]: must not begin with ! operator");
  		}
  	}

server配置上添加servlet.sesssion.cookie.name属性，但是这两个我修改后都不见效，最后还把tomcat源码
下载了下来，看它里面的代码是这么写的

```java
private static String getConfiguredSessionCookieName(Context context) {

  // Priority is:
  // 1. Cookie name defined in context
  // 2. Cookie name configured for app
  // 3. Default defined by spec
  if (context != null) {
      String cookieName = context.getSessionCookieName();
      if (cookieName != null && cookieName.length() > 0) {
          return cookieName;
      }

      SessionCookieConfig scc =
          context.getServletContext().getSessionCookieConfig();
      cookieName = scc.getName();
      if (cookieName != null && cookieName.length() > 0) {
          return cookieName;
      }
  }

  return null;
}

最终目的要把cookie名称给修改掉。

今早醒来突然想到我们的springboot应用里是根据shiro框架来实现权限和会话管理的，会不会跟这个有关系呢？脑子里突然想到这个应该是个
正确的解决方向，于是乎爬起来看了下工程代码，不看不知道，一看就知道应该就是这边的问题，我们看到shiro框架里的```DefaultWebSessionManager

```Java
   /**
	 * Create and return a new {@link StandardEnvironment}.
	 * <p>Subclasses may override this method in order to supply
	 * a custom {@link ConfigurableEnvironment} implementation.
	 */
	protected ConfigurableEnvironment createEnvironment() {
		//StandardEnvironment 构造函数 会 使他的抽象父类 也执行构造函数
		return new StandardEnvironment();
	}

那我们再来看看StandardEnvironment内部做了什么，它继承自```AbstractEnvironment```,
然后有两个私有静态final变量:

```Java
  /** System environment property source name: {@value}. */
	public static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";

	/** JVM system properties property source name: {@value}. */
	public static final String SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME = "systemProperties";

```Java
    /**
    * Customize the set of property sources with those appropriate for any standard（适用于任何标准的）
    * Java environment:
    * <ul>
    * <li>{@value #SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME}
    * <li>{@value #SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME}
    * </ul>
    * <p>Properties present in {@value #SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME} will
    * take precedence over those in {@value #SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME}.
    * @see AbstractEnvironment#customizePropertySources(MutablePropertySources)
    * @see #getSystemProperties()
    * @see #getSystemEnvironment()
    */
    @Override
    protected void customizePropertySources(MutablePropertySources propertySources) {

    //https://blog.csdn.net/rtuujnncc/article/details/78248733
    //addLast最低优先级
    //https://www.cnblogs.com/Baronboy/p/6030443.html
    propertySources.addLast(new MapPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
    propertySources.addLast(new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
    }

会先调用```AbstractEnvironment```的构造函数，函数内部会调用customizePropertySources方法，并且会把
propertySources参数传入。

```Java
  //可变的属性源集合
	private final MutablePropertySources propertySources = new MutablePropertySources();
	//把propertySources放入 Resolver中
	private final ConfigurablePropertyResolver propertyResolver =
			new PropertySourcesPropertyResolver(this.propertySources);

      /**
	 * Create a new {@code Environment} instance, calling back to
	 * {@link #customizePropertySources(MutablePropertySources)} during construction to
	 * allow subclasses to contribute or manipulate(操作) {@link PropertySource} instances as
	 * appropriate.
	 * @see #customizePropertySources(MutablePropertySources)
	 */
	//调用 子类的customizePropertySources
	public AbstractEnvironment() {
		customizePropertySources(this.propertySources);
	}

是干嘛的呢？我们看官方文档：

Interface indicating a component that contains and exposes an {@link Environment} reference.
是一个接口，它可以用来表明一个组件包含并暴露Environment的引用。我们看它的定义就知道了：

```Java
  public interface EnvironmentCapable {
  	/**
  	 * Return the {@link Environment} associated with this component.
  	 */
     //返回跟这个组件关联的环境
  	Environment getEnvironment();

  }

我们可以在ClassPathXmlApplicationContext类中自己实现，这就是一个很好的设计之处。
AbstractRefreshableApplicationContext的setConfigLocations方法如下：
```Java
  /**
	 * Set the config locations for this application context.
	 * <p>If not set, the implementation may use a default as appropriate.
	 */
	public void setConfigLocations(@Nullable String... locations) {
  if (locations != null) {

      this.configLocations = new String[locations.length];
      for (int i = 0; i < locations.length; i++) {
        this.configLocations[i] = resolvePath(locations[i]).trim();
      }
    }
    else {
      this.configLocations = null;
    }
  }

```Java
  /**
  	 * Resolve the given path, replacing placeholders with corresponding
  	 * environment property values if necessary. Applied to config locations.
  	 * @param path the original file path
  	 * @return the resolved file path
  	 * @see org.springframework.core.env.Environment#resolveRequiredPlaceholders(String)
  	 */
    protected String resolvePath(String path) {
  		return getEnvironment().resolveRequiredPlaceholders(path);
  	}