Loading Application Properties from a Database





3.00/5 (1 vote)
Use Spring and Commons Configuration to load application properties from a database
Contents
- Overview
- Getting Started
- Required Jars
- Database Table Used in this Example
- How It Works
- Spring Configuration
- Code Example
- Application Context Initialization Output
- Related Links
Overview
This example will show you how to use a DatabaseConfiguration from the Jakarta Commons Configurations project and load the Database Properties into your application context.
If you want to take advantage of the features offered in commons configuration to load your application properties into your spring context, you can use spring modules to make the properties loaded from commons configurations available within your application context.
Getting Started
To follow this example for using commons configuration with spring, you will need the jars for spring, spring-modules and commons configuration. You will also need a database available.
Required Jars
To get started with this example, you will need three jar files.
- spring.jar (Spring Core)
[PropertiesPlaceholderConfigurer]
- spring-modules.jar (Spring Modules)
[CommonsConfigurationFactoryBean]
- commons-configuration.jar (Commons Configuration)
[DatabaseConfiguration]
Database Table Used in this Example
For this example, the database has a schema in it called TEST_SCHEMA
and a table called APPLICATION_PROPERTIES_TABLE
with two columns KEY
and VALUE*
.
TEST_SCHEMA.APPLICATION_PROPERTIES_TABLE
KEY | VALUE |
key.one |
value one |
file.location |
somewhere/on/the/filesystem |
pet.dogs.name |
bart |
* Note that this is only one example of a usable table structure.
How It Works
- The
DatabaseConfiguration
is initialized from the injected datasource and is configured to load the properties from the tableTEST_SCHEMA.APPLICATION_PROPERTIES
using the columnKEY
as the key andVALUE
as the value. - The
CommonsConfigurationFactoryBean
is initialized with theDatabaseConfiguration
? bean as its configuration (It can have many but that is not used in this example). - The
PropertyPlaceholderConfigurer
is initialized with properties attribute being set to theCommonsConfigurationFactoryBean
. TheCommonsConfigurationFactoryBean
? is a FactoryBean that creates aProperties
object. - The
PropertyPlaceholderConfigurer
then makes the properties available to any bean within the current spring configuration file via the${}
notation. - The
PropertiesPrinter
is then initialized with the propertiesfile.location
,pet.dogs.name
andfile.location
. displayAllProperties() (initMethod)
is then called on thePropertiesPrinter
? and the following would be output:
File Location : somewhere/on/the/filesystem
Pet dogs name : bart
Key one : value one
In Summary
PropertiesPlaceholderConfigurer
[Spring-Core] makes its properties available within the application context.CommonsConfigurationFactoryBean
[Sprint Modules] creates a properties object using classes from commons configuration.DatabaseConfiguration
[Commons Configuration] loads properties from a database table.
Spring Configuration
<!-- Required to connect to datasource -->
<bean name="PropertyPlaceholderConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="properties" ref="CommonsConfigurationFactoryBean"/>
</bean>
<bean name="CommonsConfigurationFactoryBean"
class="org.springmodules.commons.configuration.CommonsConfigurationFactoryBean">
<constructor-arg ref="DatabaseConfiguration"/>
</bean>
<bean name="DatabaseConfiguration"
class="org.apache.commons.configuration.DatabaseConfiguration">
<constructor-arg type="javax.sql.DataSource" ref="someDataSource"/>
<constructor-arg index="1" value="TEST_SCHEMA.APPLICATION_PROPERTIES_TABLE"/>
<constructor-arg index="2" value="KEY"/>
<constructor-arg index="3" value="VALUE"/>
</bean>
<!-- Included to elaborate functionality -->
<bean name="PropertiesPrinter " class="example.PropertiesPrinter"
initMethod="displayAllProperties">
<property name="fileLocation" value="${file.location}"/>
<property name="petDogsName" value="${pet.dogs.name}"/>
<property name="keyOne" value="${key.one}"/>
</bean>
Code Example
package example;
public class PropertiesPrinter {
public String fileLocation;
public String petDogsName;
public String keyOne;
public void setFileLocation(String fileLocation) {
this.fileLocation = fileLocation;
}
public void setPetDogsName(String petDogsName) {
this.petDogsName = petDogsName;
}
public void setKeyOne(String keyOne) {
this.keyOne = keyOne;
}
public void displayAllProperties() {
System.out.println("File Location : " + this.fileLocation);
System.out.println("Pet dogs name : " + this.petDogsName);
System.out.println("Key one : " + this.keyOne);
}
}
Application Context Initialization Output
File Location : somewhere/on/the/filesystem
Pet dogs name : bart
Key one : value one