First, we know the environment information in which the entire Spring application runs: Profiles + Properties

First look at profiles, which is configured in the code as:

spring.profiles.active=prd/test/dev...
Copy the code

Profiles functions to logically group beans

Define a ProfileService class with a private property profile as follows:

Create a New ProfileConfiguration configuration class and define the ProfileService instance bean here. When the SpringBoot project starts, the ProfileService instance bean will be loaded into the IOC container. Here’s the whole thing:

On each bean in the ProfileConfiguraiton configuration class, add the @profile annotation to simulate setting up beans for two different environments and declare beans for different environments

Goldfinger: Use @Profile to logically distribute XML and annotations for different beans

Before starting, set the profile in the Environment, setActiveProfile(). Nib is an array, which can be set to hide, for testing purposes. Set “PRD” first, and context.getBean will fetch the bean from the IOC container and print it to the console.

In general, both getBean and @AutoWired can fetch beans from an IOC container.

Run the SpringBoot project, and if you print beans in the IOC container, beans in the PRD environment, it’s ok.

At this point, profiles for env has been set successfully.

The setActiveProfiles() argument is an array and can be set to more than one, as follows:

This completes the tutorial on Env profiles.

Create a new UserController class and print the env property in the application.properties configuration file as follows:



The env attribute in the application.properties configuration file is “Hello world” and configured as follows:

Run successfully, retrieved as follows:

So, we see that properties holds the environment or file information for the property.

We use @autowired to fetch the Environment instance bean from the Spring IOC container, and then directly fetch the Environment instance bean (without @value) as follows:

There are two ways to fetch instance beans from the Spring IOC container, the getBean method or the @AutoWired annotation.

Look, it’s printed, too.

Find the Environment interface first

As you can see, if the class variable env is not null, it is returned directly. If it is null, a new class instance is returned based on the webApplicationType instance.

So there are three classes involved in the getOrCreateEnvironment() method: StandardEnvironment StandardServletEnvironment StandardReactiveWebEnvironment, these three classes inherit AbstractEnvironment, AbstractEnvironment inherits the Environment interface as follows:

See AbstractEnvironment first class

Since the AbstractEnvironment class’s customizePropertySources() is an empty implementation, look at its subclass, the StandardEnvironment class.

StandardEnvironment class has only one customizePropertySources method, also finished, and the StandardServletEnvironment class.

CustomizePropertySources () takes the mutable argument source as input and is essentially a MutablePropertySources class object. Let’s look at the MutablePropertySources class, which is defined as follows:

Let’s take a look at StandardServletEnvironment add three properties of is what

When we use Spring + SpringMVC, we need to configure a web.xml, In web.xml, you need to configure two tags < context-params>< /context-params> and < init-params>< /init-params>, and we just used it like this, and in fact, The two tags in web.xml are configured as attributes in env.

Public static final String SERVLET_CONTEXT_PROPERTY_SOURCE_NAME = “servletContextInitParams”; < context-params>< /context-params> public static final String SERVLET_CONFIG_PROPERTY_SOURCE_NAME = “ServletConfigInitParams”; < init-params>< /init-params>

We know StandardEnvironment: system variable + system environment variable

/** 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";
Copy the code

Above, the former represents the system environment variable, so we just accessed the system environment variable with @value (“${java.version}”), and the latter represents the system property.

We now complete the figure, a figure summary source structure:

Last question, how to determine the configuration order and priority?

Answer: whether StandardEnvironment classes and class or StandardServletEnvironment, are using addLast add attribute, the order of all attributes is the source code from top to bottom.

All right,ConfigurableEnvironment environment = getOrCreateEnvironment();This line of code, return to SpringApplication class, see configureEnvironment (environment, applicationArguments getSourceArgs ()); This line of code.

ConfigureEnvironment () is executed after creating/retrieving an env instance as follows:



In the configureEnvironment() method, the first argument is the ConfigurableEnvironment class object, which is the env object. The second parameter is a class object DefaultApplicationArguments. GetSourceArgs (), it is new in the source code, the following (short answer to understand good, as long as know the command line parameters can be identified as well) :



To get to the point, see the configureEnvironment method as follows:

The class variable addConversionService defaults to true,

private boolean addConversionService = true;
Copy the code

It represents a universal conversion, and when true, executes the if block, gets a conversionService, and sets it to the Spring framework env.

Further down, you can see that the configureEnvironment method executes two methods in sequence: configurePropertySources(Environment, ARGS); And configureProfiles (environment, args); Is the environment information for the entire Spring application to run: Profiles + Properties, which is resolved in these two methods.

Create a new LinkedHashSet based on additionalProfiles, and place all the profiles properties in the env variable into this set. Turn the set into a string and put it in env.

Ok, let’s go to the setActiveProfiles() method, as follows:



SetActiveProfiles () sets the profile in env

As for the configureProfiles method, doesn’t that seem to make any sense? Put profiles in an env in a set, and then set in an env.

Note, however, that the setActiveProfiles() method in the AbstractEnvironment class accepts a String mutable array and puts the String profile into a Set of activeProfiles. Because sets can be multiple, they cannot have the same string name.

In fact, we used this method from the very beginning, setting a profile in env that takes an array of two strings “PRD” and “env”, ensuring that they are both arrays and have no duplicate names.

In fact, it is set in the application.properties file as well as in Run/Debug Configurations, where setActiveProfiles() is called.

As a refresher, the common listening logic in Spring is: define an event class, the event publisher publishes a custom event, and the time receiver Listener receives the custom event and its subclasses.

Enter the listeners. EnvironmentPrepared (environment);



Enter the environmentPrepared method as follows:

Take a look at the specific logic of broadcast events as follows:



Enter the invokeListener method as follows:

This listener. OnApplicationContext (event) is said after listening to the event trigger eavesdroppers to complete the corresponding logic.

Ok, let’s review the call relationship as follows:



The onApplicationEvent method has several methods, such as the following:



Arbitrary find a, here ConfigFileApplicationListener class, you can see for through the event types, performs a different operation, are as follows:

The second method for onApplicationEvent onApplicationPreparedEvent, as follows:



EnvironmentPostProcessor has a number of implementation classes, as follows:



Find a few EnvironmentPostProcessor implementation class, choose SpringApplicationJsonEnvironmentPostProcessor kind here, this class, the two interfaces, The EnvironmentPostProcessor interface is extended and the Ordered interface is Ordered, as follows:

Let’s meet this RandomValuePropertySource class, annotation on the class and tell us how to configure, as follows:

There are two constants in the class. The default random attribute is named random and prefixed with random., as follows:

GetProperty: Returns null if name is not prefixed with random. When name is prefixed with random., the getRandomValue method is called to return a random value.

The getRandomValue method returns a random value based on the prefix length of the string argument name.

Ok, we according to the configuration of RandomValuePropertySource class automatically to give it a try, equipped with a name for randomLong, value is random. The long, The bottom is generated by RandomValuePropertySource getRandomValue method of a class, the configuration is as follows:

The main code retrieves the attribute Value via @value or the Environment bean instance, which is used as follows:



Run, really get it out

The refresh changes again and again, each time generating a random long, haha

Ok, play enough, back to ConfigFileApplicationListener addPropertySources method of a class: to add, the new Loader, perform the load method.

Go to the addToEnvironment() method, where addAfter just adds the random property.



Env as shown in figure:

Back to ConfigFileApplicationListener class, check the new Loader (environment, resourceLoader). The load ();

Loader is a resource file Loader

The Loader class constructor sets four class attributes as follows:



See the fourth sentence, as follows:

this.propertySourceLoaders = SpringFactoriesLoader.
     loadFactories(PropertySourceLoader.class,getClass().getClassLoader());
Copy the code

To see the first SpringFactoriesLoader loadFactories method, this method is loaded spring. The factories in the configuration file data,

Looking at the PropertySourceLoader interface itself, this interface contains only two methods, a method to get file extensions and a method to load.

Look at the load method

Enters FilteredPropertySource. The apply () method, which is as follows:

FilteredPropertySource.java static void apply(ConfigurableEnvironment environment, String propertySourceName, Set<String> filteredProperties, Consumer<PropertySource<? >> operation) { In variable attributes in the source propertySources MutablePropertySources propertySources = environment. GetPropertySources (); // in the variable PropertySource propertySources, get the propertySourceName PropertySource<? > original = propertySources.get(propertySourceName);if(original == null) { operation.accept(null); // If null is retrieved, execute operation.acceptreturn; } // If propertySourceName is not null, the propertySourceName exists. Replace (propertySourceName, new FilteredPropertySource(original, filteredProperties)); try { operation.accept(original); } finally { propertySources.replace(propertySourceName, original); }}Copy the code

Go back to the load method and see the initializeProfiles method



Enter the initializeProfiles method, which initializes the Profiles property with the following logic:

Enter the getOtherActiveProfiles method as follows:

After going through the Loader constructor and having the Loader object, look at the load method as follows:

Enter the load method as follows:

Debug executes as follows:





Enter the loadForFileExtension method as follows: