Spring Property Injection Concepts

From NovaOrdis Knowledge Base
Jump to navigation Jump to search

Internal

Overview

Spring has two different, but related kinds of configurations: bean wiring, which refers to declaring application components and their dependencies, and how those dependencies should be injected into each other, as described in the Dependency Injection and Inversion of Control Container section, and property injection, which is the process that allows external pieces of data, known as configuration properties, to be provided to the application runtime at startup or while it is running, in form of Java system properties, environment variables and by other means. This section addresses property injection concepts.

The Environment Abstraction

The environment is an abstraction integrated in the container that models two key aspects of the application environment: configuration properties and profiles.

The environment can be obtained directly from the application context, as follows:

import org.springframework.core.env.Environment;
...
ApplicationContext applicationContext = ...
applicationContext.getEnvironment();

The environment can be injected into a component and accessed programmatically as follows:

@Autowired
private Environment environment;

Configuration Properties

Configuration properties are pieces of data coded into Spring components using the JavaBeans property conventions. They usually have a corresponding member variable, a getter and a setter. The Spring Framework provides conventions and mechanisms to automatically inject values into configuration properties, while those values come from several different property sources.

The environment provides the user with a convenient service interface for configuring property sources and resolving properties from them.

The Spring environment is the only source of configuration properties for components needing them. The environment abstracts the origins of properties and applies precedence rules when the same property is specified in more than one source. It pulls property values from several sources: Java system properties, command-line arguments, environment variables, configuration files, etc. The property sources are described in detail in their corresponding sections, below.

Reading Properties from Environment

The availability of a property in one of the environment's property sources can be checked with:

if (environment.containsProperty(propertyName)) {
  ...
}

If the property is available, it can be obtained with:

environment.getProperty(propertyName);

The PropertySource Abstraction

The Spring environment abstraction integrates and searches over a configurable hierarchy of property sources. To figure out whether a specific property was declared and to obtain its value, the environment performs a search over a set of PropertySource objects.

The mechanism is configurable, custom property sources can be integrated.

Property Sources

Java System Properties

Java system properties are exposed to the environment via a PropertySource wrapped around System.getProperties(). Properties declared with -D on java command line are available via the environment abstraction.

Command-Line Arguments

java -jar ... --<property.name>=<value>

Example:

java -jar ... --server.port=9999

Environment Variables

Environment variables are exposed to the environment via a PropertySource wrapped around System.getenv().

The naming style should accommodate restrictions placed on environment variable names by the operating system.

export SERVER_PORT=9999

Map Objects

Property Configuration Files

application.properties

application.properties

JNDI

Servlet Configuration

Servlet configuration is accessible through a StandardServletEnvironment.

Servlet Context Parameters

Servlet context parameters are accessible through a StandardServletEnvironment.

Configuration Service

The configuration service is also referred to as configuration server.

Custom Property Source

API

ConfigurableApplicationContext ctx = ...
MutablePropertySources sources = ctx.getEnvironment().getPropertySources();
sources.addFirst(new MyPropertySource());

@PropertySource

@PropertySource

Precedence

Property values are not merged but rather completely overridden by a preceding entry.

For a StandardEnvironment, the full hierarchy is as follows, with the highest-precedence entries at the top:

For a StandardServletEnvironment, the full hierarchy is as follows, with the highest-precedence entries at the top:

  1. ServletConfig parameters.
  2. ServletContext parameters (web.xml context-param entries).
  3. JNDI environment variables (java:comp/env/ entries).
  4. JVM system properties (-D command-line arguments).
  5. OS environment variables.

Profiles

A profile is a named, logical group of bean definitions and configuration properties to be registered with the container only if the given profile is active. Beans may be assigned to a profile whether they are defined in XML or with annotations. The environment determines which profiles - if any - are currently active, and which profiles - if any - should be active by default.

Default Profile

A default profile represents the profile (or profiles) that are enabled by default. The default profile's name is "default". Components can be declared to be registered by default, probably redundantly with:

@Profile("default")
...

If no profile is active, all components belonging to the default profile are created and registered. The default profile is a way to provide a default definition for one or more beans. If any profile is enabled, the default profile does not apply. The name of the default profile can be changed by using setDefaultProfiles() on the Environment or declaratively by using the "spring.profiles.default" property.

Active Profile

More than one profile can be active at a time.

Profile Expressions

Profiles and Bean Registration

@Profile

@Profile

Deplete This:

tmp