The first step to connect to a database from any Java application is to obtain a connection object specified by JDBC. DataSource, a part of Java SE, is a generalized factory of java.sql.Connection objects that represents the physical connection to the database and is the preferred means of producing a connection. DataSource handles transaction management, connection lookup, and pooling functionalities, relieving the developer of those infrastructural issues.

DataSource objects are often implemented by database driver vendors and typically looked up via JNDI. Application servers and Servlet engines provide their own implementations of DataSource (and) or connectors to DataSource objects provided by the database vendor. Typically configured inside XML-based server descriptor files, server-supplied DataSource objects generally provide built-in connection pooling and transaction support. As a developer, you just configure your data sources inside the server configuration files declaratively in XML and look them up from your application via JNDI.

In a Spring application, you configure your DataSource reference as a Spring bean, and inject it as a dependency into your DAOs or other persistence resources. The Spring <jee:jndi-lookup/> tag (of http://www.springframework.org/schema/jee namespace) allows you to look up and construct JNDI resources easily, including a DataSource object defined from inside an application server. For applications deployed in a J2EE application server, a JNDI DataSource object provided by the container is recommended.

<jee:jndi-lookup id="taskifyDS" jndi-name="java:jboss/datasources/taskify"/>

For standalone applications, you need to create your own DataSource implementation or use third-party implementations such as Apache Commons DBCP, C3P0, or BoneCP. The following is a sample DataSource configuration using Apache Commons DBCP2. It provides configurable connection pooling features too.

<bean id="taskifyDS" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="${driverClassName}" />
    <property name="url" value="${url}" />
    <property name="username" value="${username}" />
    <property name="password" value="${password}" />
    <property name="initialSize" value="3" />
    <property name="maxTotal" value="50" />
    ...
</bean>

Make sure you add the corresponding dependency to your DataSource implementation in your build file. The following is for DBCP2:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-dbcp2</artifactId>
    <version>2.1.1</version>
</dependency>

Spring provides DriverManagerDataSource, a simple implementation of DataSource, which is only meant for testing and development purposes, not for production use. Note that it does not provide connection pooling. Here is how you configure it in your application.

<bean id="taskifyDS" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="${driverClassName}" />
    <property name="url" value="${url}" />
    <property name="username" value="${username}" />
    <property name="password" value="${password}" />
</bean>

It can also be configured using the Java-based configuration, as shown in the following code:

@Bean
DataSource getDatasource() {
    DriverManagerDataSource dataSource = new DriverManagerDataSource(pgDsProps.getProperty("url"));
    dataSource.setDriverClassName( pgDsProps.getProperty("driverClassName"));
    dataSource.setUsername(pgDsProps.getProperty("username"));
    dataSource.setPassword(pgDsProps.getProperty("password"));
    return dataSource;
}