Home  >  Spring Core

Spring PropertyPlaceholderConfigurer Example

By Arvind Rai, June 23, 2019
On this page we will provide spring PropertyPlaceholderConfigurer example using annotation and XML to externalize property values. In case of XML, simply create bean for PropertyPlaceholderConfigurer and set the location of property file to externalize. In case of annotation, we need to create static bean of PropertyPlaceholderConfigurer in java configuration.
PropertyPlaceholderConfigurer is used to resolve ${...} placeholders against a property. It can be local properties or system properties or environment variables. We can use PropertyPlaceholderConfigurer using XML as well as annotation.
PropertyPlaceholderConfigurer externalizes the property configuration. Setting hard coded property values in our code is not good coding style. Properties should be configured in a property file inside or outside application. So that changing properties frequently will not cause to change the code. Here on this page we will provide complete example for PropertyPlaceholderConfigurer using XML as well annotation.

PropertyPlaceholderConfigurer using XML

For the PropertyPlaceholderConfigurer demo in XML , we are using an application which will interact with database. We will externalize our JDBC connection properties in a property file.

XML for PropertyPlaceholderConfigurer

Find the application context XML file.
app-conf.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations" value="classpath:jdbc.properties" />
	</bean>
	<bean id="dtSource" destroy-method="close" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	<bean id="villageDAO" class="com.concretepage.VillageDAO">
		<constructor-arg name="dataSource" ref="dtSource"/>
	</bean>
</beans> 



Create Table in MySQL

Create a table in MySQL in which we will insert the data and then select it.
Table: village
CREATE TABLE `village` (
`name` VARCHAR(50) NULL DEFAULT NULL,
`district` VARCHAR(50) NULL DEFAULT NULL
)
COLLATE='latin1_swedish_ci'
ENGINE=InnoDB; 

Create JDBC Property File to Externalize Property Values

Create a JDBC property file where we will configure our JDBC connection properties.
jdbc.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/concretepage
jdbc.username=root
jdbc.password= 

Create DAO

Find a DAO class used in our demo.
VillageDAO.java
package com.concretepage;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
public class VillageDAO {
	private DataSource dataSource;
	public VillageDAO(DataSource dataSource){
		this.dataSource= dataSource;
	}
	public void save() throws SQLException{
		Connection con=dataSource.getConnection();
		Statement st= con.createStatement();
		st.executeUpdate("insert into village values ('dhananjaypur','varanasi')");
	}
	public Map<String, String> selectFirstRow() throws SQLException {
		Connection con=dataSource.getConnection();
		Statement st= con.createStatement();
		ResultSet rs = st.executeQuery("select name, district from village");
		rs.first();
		Map<String, String> map = new HashMap<>();
		map.put("name", rs.getString(1));
		map.put("district", rs.getString(2));
		System.out.println(map);
		return map;
	}
} 

Run Demo

Run the demo.
SpringDemo.java
package com.concretepage;
import java.sql.SQLException;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringDemo {
	public static void main(String[] args) throws SQLException {
		AbstractApplicationContext  context = new ClassPathXmlApplicationContext("app-conf.xml");
		VillageDAO vill=(VillageDAO)context.getBean("villageDAO");
		vill.save();
		vill.selectFirstRow();
		context.registerShutdownHook();
	}
} 
Find the output.
{district=varanasi, name=dhananjaypur}
 

Gradle File

Find the gradle file to resolve the JAR dependencies.
build.gradle
apply plugin: 'java'
apply plugin: 'eclipse'
archivesBaseName = 'SpringDemo'
version = '1' 
repositories {
    mavenCentral()
}
dependencies {
    compile 'org.springframework.boot:spring-boot-starter:1.2.7.RELEASE'
    compile 'commons-dbcp:commons-dbcp:1.4'
    compile 'mysql:mysql-connector-java:5.1.31'
}  

PropertyPlaceholderConfigurer using Annotation

To use PropertyPlaceholderConfigurer using annotation, we will create a static bean of it in java configuration class. To externalize the properties we will use PropertyPlaceholderConfigurer with @PropertySource and @Value.

@PropertySource: It loads property file.
@Value: It is used for expression-driven dependency injection.

Java Configuration: Create Static Bean for PropertyPlaceholderConfigurer

We will create a static bean of PropertyPlaceholderConfigurer in java configuration. The reason to create @Bean method as static is that it must be instantiated very early in the spring container life-cycle. And hence PropertyPlaceholderConfigurer bean will interfere with processing of @Value annotation.
AppConfig.java
package com.concretepage;
import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
@Configuration
@PropertySource("classpath:jdbc.properties")
public class AppConfig {
	 @Value("${jdbc.driverClassName}")
	 private String driverClassName;
	 @Value("${jdbc.url}")
	 private String jdbcURL;
	 @Value("${jdbc.username}")
	 private String username;
	 @Value("${jdbc.password}")
	 private String password;	 
         @Bean
	 public DataSource getDataSource() {
	    BasicDataSource dataSource = new BasicDataSource();
	    dataSource.setDriverClassName(driverClassName);
	    dataSource.setUrl(jdbcURL);
	    dataSource.setUsername(username);
	    dataSource.setPassword(password);
	    return dataSource;
	 }
	 @Bean
	 public VillageDAO villageDAO(DataSource dataSource) {
		return new VillageDAO(dataSource);
	 }
	 @Bean
	 public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer() {
		return new PropertySourcesPlaceholderConfigurer();
	 }	 
} 

Run Demo

Run the demo.
SpringDemo.java
package com.concretepage;
import java.sql.SQLException;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class SpringDemo {
	public static void main(String[] args) throws SQLException {
	    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
	    ctx.register(AppConfig.class);
	    ctx.refresh();
	    VillageDAO villageDAO = ctx.getBean(VillageDAO.class);
	    villageDAO.save();
	    villageDAO.selectFirstRow();
    	    ctx.registerShutdownHook();
	}
}  
Find the output.
{district=varanasi, name=dhananjaypur}
 

Download Source Code

POSTED BY
ARVIND RAI
ARVIND RAI
FIND MORE TUTORILAS






©2019 concretepage.com | Privacy Policy | Contact Us