Datasource configuration with Spring Boot

For configuring a datasource using Spring Boot we have couple of options. With the help of a simple example project, which is available on my github profile, I will walk you through these options. The example contains two simple entities Portal and Page with a 1:N bidirectional relationship.

	@Entity
	public class Portal extends AbstractPersistable<Long> {
	private String name;
	@OneToMany(mappedBy = "portal", cascade = CascadeType.ALL)
	private List<Page> pages;
	...
	}

view raw Portal.java hosted with ❤ by GitHub

	@Entity
	public class Page extends AbstractPersistable<Long> {
	private String name;
	@ManyToOne
	private Portal portal;
	...
	}

view raw Page.java hosted with ❤ by GitHub

The example with the help of Spring Data JPA and REST modules, creates and exposes CRUD operations for these entities using plain HTTP REST semantics.

	public interface PageRepository extends CrudRepository<Page, Long> {
	}
	public interface PortalRepository extends CrudRepository<Portal, Long> {
	}

view raw Repositories.java hosted with ❤ by GitHub

	<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-jpa</artifactId>
	</dependency>
	<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-rest</artifactId>
	</dependency>

view raw pom.xml hosted with ❤ by GitHub

In development mode it is very convenient to use an in-memory database. By simply including H2 as a maven dependency, Spring Boot uses it as an in-memory database, no connection URL needs to be provided. This example uses the Spring Data JPA interface to populate the database with some example data.

	@Service
	@Profile("default")
	public class DatabaseLoader {
	private final PageRepository pageRepository;
	private final PortalRepository portalRepository;
	@Autowired
	public DatabaseLoader(PageRepository pageRepository, PortalRepository portalRepository) {
	this.pageRepository = pageRepository;
	this.portalRepository = portalRepository;
	}
	@PostConstruct
	private void initDatabase() {
	Portal portal = new Portal("ABN AMRO Retail Banking");
	portalRepository.save(portal);
	Page page = new Page();
	page.setName("login");
	page.setPortal(portal);
	pageRepository.save(page);
	page = new Page();
	page.setName("accounts");
	page.setPortal(portal);
	pageRepository.save(page);
	page = new Page();
	page.setName("profile");
	page.setPortal(portal);
	pageRepository.save(page);
	}
	}

view raw DatabaseLoader.java hosted with ❤ by GitHub

Using the @Profile("default") this bean will be just initialised in the default Spring profile (when no other profile is specified). We could have created an explicit profile for development mode also, but this example is just using the default for this.
Next we just need to start the application. With the following glue code we can start it as a standalone application (java -jar). It will also work if we drop the produced war file in a Servlet 3.0 servlet container.

	@ComponentScan
	@EnableAutoConfiguration
	public class Application extends SpringBootServletInitializer {
	public static void main(String[] args) {
	SpringApplication.run(Application.class, args);
	}
	@Override
	protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
	return application.sources(Application.class);
	}
	}

view raw Application.java hosted with ❤ by GitHub

Setting to debug level the org.hibernate.SQL logger, we can see the that database schema was created and populated during application startup.

	2014-10-25 22:47:22.337 DEBUG 22802 --- [ost-startStop-1] org.hibernate.SQL : drop table page if exists
	2014-10-25 22:47:22.337 DEBUG 22802 --- [ost-startStop-1] org.hibernate.SQL : drop table portal if exists
	2014-10-25 22:47:22.337 DEBUG 22802 --- [ost-startStop-1] org.hibernate.SQL : create table page (id bigint generated by default as identity, name varchar(255), portal_id bigint, primary key (id))
	2014-10-25 22:47:22.341 DEBUG 22802 --- [ost-startStop-1] org.hibernate.SQL : create table portal (id bigint generated by default as identity, name varchar(255), primary key (id))
	...
	2014-10-25 22:47:23.292 DEBUG 22802 --- [ main] org.hibernate.SQL : insert into portal (id, name) values (null, ?)
	2014-10-25 22:47:23.315 DEBUG 22802 --- [ main] org.hibernate.SQL : insert into page (id, name, portal_id) values (null, ?, ?)
	2014-10-25 22:47:23.318 DEBUG 22802 --- [ main] org.hibernate.SQL : insert into page (id, name, portal_id) values (null, ?, ?)
	2014-10-25 22:47:23.319 DEBUG 22802 --- [ main] org.hibernate.SQL : insert into page (id, name, portal_id) values (null, ?, ?)

view raw logs.log hosted with ❤ by GitHub

In a production environment however is unlikely that we need to create the database schema and populate the database. We just need to tell to Spring Boot where and how to connect to the database. Since we would like to keep the ability to work with the app in development mode, the solution is to use another Spring profile for the production setup. Creating the application-production.properties configuration with the below properties (using mysql in this example) we can instruct Spring Boot to switch to production mode by setting the spring.profiles.active to production

	spring.jpa.hibernate.ddl-auto=none
	spring.datasource.url=jdbc:mysql://localhost/test
	spring.datasource.username=
	spring.datasource.password=

view raw application-production.properties hosted with ❤ by GitHub

As you can see the jdbc driver class name is not needed, Spring Boot can infer it from the database URL. Have a look at the DriverClassNameProvider for the details.
With the next release of Spring Boot (in 1.2.0-SNAPSHOT is already available) it will be possible to reference the datasource via JNDI, which is very common in traditional deployment setups where the datasources are configured inside the application server. Of course we can do this already with Spring using JndiDataSourceLookup but it got easier using Spring Boot, without using infrastructure beans. In order to demonstrate this, I have deployed the application into JBoss Wildfly, and created another Spring profile called jboss with the following configuration

spring.datasource.jndi-name=java:jboss/datasources/MySQLDataSource

view raw application-jboss.properties hosted with ❤ by GitHub

Using the default standalone.xml as the initial configuration the datasource connecting to MySQL can be added like in the example below.

	...
	<subsystem xmlns="urn:jboss:domain:datasources:2.0">
	<datasources>
	<datasource jndi-name="java:jboss/datasources/MySQLDataSource" pool-name="MySQLDataSourcePool" enabled="true" use-java-context="true">
	<connection-url>jdbc:mysql://localhost/test</connection-url>
	<driver>mysql</driver>
	</datasource>
	<drivers>
	<driver name="mysql" module="com.mysql">
	<datasource-class>com.mysql.jdbc.Driver</datasource-class>
	</driver>
	</drivers>
	</datasources>
	</subsystem>
	...

view raw standalone-backbase.xml hosted with ❤ by GitHub

We also need to create a module.xml in the JBOSS_WILDFLY_HOME/modules/com/mysql/main folder with the following configuration. The mysql jdbc driver needs to be put into this folder also.

	<?xml version="1.0" encoding="UTF-8"?>
	<module xmlns="urn:jboss:module:1.3" name="com.mysql">
	<resources>
	<resource-root path="mysql-connector-java-5.1.32.jar"/>
	</resources>
	<dependencies>
	<module name="javax.api"/>
	<module name="javax.transaction.api"/>
	</dependencies>
	</module>

view raw module.xml hosted with ❤ by GitHub

Next, by dropping the created war file into JBOSS_WILDFLY_HOME/standalone/deployments folder and executing the following command we can startup this simple application in JBoss.

SPRING_PROFILES_ACTIVE=jboss ./standalone.sh -c standalone-backbase.xml

view raw start-jboss.sh hosted with ❤ by GitHub

Accessing the http://localhost:8080/datasource-configuration-1.0-SNAPSHOT/ you will see that the data is loaded from MySQL end exposed with Spring Data REST. If you would like to try it out this example, have a look at my github profile.

Software configuration with Spring Boot

In this blog post I would like to show you the configuration possibilities of a Spring bean's name property in combination with Spring Boot. Let's consider the following simple bean.

	@Service
	public class GreetingService {
	private static final Logger LOGGER = LoggerFactory.getLogger(GreetingService.class);
	@Value("${greeting.name:World}")
	private String name;
	public String greet() {
	if (LOGGER.isDebugEnabled()) {
	LOGGER.debug("Greeting {}", name);
	}
	return "Hello " + name;
	}
	}

view raw GreetingService.java hosted with ❤ by GitHub

The @Value("${greeting.name:World}") means that the name can be configured via the greeting.name property and has the default value of "World". You can quickly try it by cloning my example repository which I have created for this blog post and accessing the http://localhost:8080

	git clone https://github.com/altfatterz/configuration-with-spring-boot
	cd configuration-with-spring-boot
	mvn clean package
	java -jar target/configuration-with-spring-boot-0.0.1-SNAPSHOT.war

view raw try.sh hosted with ❤ by GitHub

With the help of Spring Boot Maven Plugin this example is creating a very simple war artifact starting an embedded tomcat instance.
Now let's see what configuration options we have.
We can configure the name property using a command line argument.

java -jar target/configuration-with-spring-boot-0.0.1-SNAPSHOT.war --greeting.name=Zoltan

view raw command-line.sh hosted with ❤ by GitHub

We can set it also via a system property.

java -Dgreeting.name="Heisenberg" -jar target/configuration-with-spring-boot-0.0.1-SNAPSHOT.war

view raw system-property.sh hosted with ❤ by GitHub

Or we can use an OS environment variable.

GREETING_NAME="Dexter" java -jar target/configuration-with-spring-boot-0.0.1-SNAPSHOT.war

view raw environment-variable.sh hosted with ❤ by GitHub

Here you can see that I have used underscore since the OS does not allow me to use period-separated key name. But is not a problem for Spring Boot, it can match it.
The Spring Boot Actuator module's /env endpoint can be very useful in analysing used configuration.

We could also set it via a JNDI attribute. In order to demonstrate it, I will use Wildfly (formerly known as JBoss AS). Just drop the generated war file into your /standalone/deployments and after you have started the server (/bin/standalone.sh) add a JNDI binding via JBoss CLI tool.

	$ ./jboss-cli.sh -c "/subsystem=naming/binding=java\:\/greeting.name:add(binding-type=simple,value=Backbase)"
	{"outcome" => "success"}
	$ ./jboss-cli.sh -c "reload"

view raw jboss-jndi-binding.sh hosted with ❤ by GitHub

And accessing the http://localhost:8080/configuration-with-spring-boot-0.0.1-SNAPSHOT/ you will see the name property was set via JNDI. The interested reader can have a look what modifications I needed to make to able to deploy it to JBoss EAP 6.3.0.

Another option is to set it via an external property file. By default it uses the application.properties, however you can easily override it via spring.config.name as shown below.

java -jar target/configuration-with-spring-boot-0.0.1-SNAPSHOT.war --spring.config.name=backbase

view raw backbase.properties hosted with ❤ by GitHub

You can group configuration in profiles. With Spring profiles you can achieve that you have one deployable artifact across development, staging and live environments, running on your laptop, application server or on a PaaS provider. Achieving this makes testing very easy.

Lastly I would like to show you how Spring Boot can help in setting up logging configuration. Spring Boot already provides a default base configuration for each logging implementation that you can include if you just want to set levels. The base configuration is set up with console output and file output (rotating, 10 Mb file size) which is usually enough.

	<?xml version="1.0" encoding="UTF-8"?>
	<configuration>
	<include resource="org/springframework/boot/logging/logback/base.xml"/>
	<logger name="com.backbase" level="INFO"/>
	</configuration>

view raw logging.xml hosted with ❤ by GitHub

With the logging.file you can configure the file output location.
What you would however mostly do is to setup an externalised logging configuration. For logging I recommend logback. It can automatically reload logging configuration upon modification. The external logging configuration you can set via the logging.config property.

java -jar target/configuration-with-spring-boot-0.0.1-SNAPSHOT.war --logging.config=backbase-logback.xml

view raw backbase-external-logback.sh hosted with ❤ by GitHub

You should also customise the banner for your app :) I used this tool.



Hope you see the great flexibility regarding configuration when using Spring Boot. There are other goodies like using YAML instead of properties files, which is a very convenient format for specifying hierarchical configuration data.