The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Configuring Data Sources

Next ►
►

In this section, we will explore how to configure data sources in a Spring Boot application. Configuring data sources is a crucial step in setting up your application to interact with a database. We will cover the following topics:

  1. Introduction to Data Sources
  2. Configuring Data Sources using application.properties
  3. Configuring Data Sources using Java Configuration
  4. Using Multiple Data Sources
  5. Practical Exercises

  1. Introduction to Data Sources

A data source is a Java object that provides a connection to a database. In Spring Boot, data sources are typically configured using properties files or Java configuration classes. Spring Boot simplifies the process by providing auto-configuration for data sources.

  1. Configuring Data Sources using application.properties

Spring Boot allows you to configure your data source directly in the application.properties file. Here is an example configuration for a MySQL database:

# application.properties

# DataSource settings
spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# Hibernate settings
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

Explanation:

  • spring.datasource.url: The JDBC URL of the database.
  • spring.datasource.username: The username to connect to the database.
  • spring.datasource.password: The password to connect to the database.
  • spring.datasource.driver-class-name: The fully qualified name of the JDBC driver.
  • spring.jpa.hibernate.ddl-auto: Specifies the action to be taken by Hibernate at startup for schema management.
  • spring.jpa.show-sql: Enables logging of SQL statements.
  • spring.jpa.properties.hibernate.dialect: Specifies the Hibernate dialect to use.

  1. Configuring Data Sources using Java Configuration

Alternatively, you can configure your data source using a Java configuration class. This approach provides more flexibility and is useful for complex configurations.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
}

Explanation:

  • @Configuration: Indicates that the class contains Spring configuration.
  • @Bean: Marks a method as a bean producer.
  • @ConfigurationProperties(prefix = "spring.datasource"): Binds the properties prefixed with spring.datasource to the DataSource bean.

  1. Using Multiple Data Sources

In some applications, you may need to connect to multiple databases. Spring Boot allows you to configure multiple data sources by defining multiple DataSource beans.

Example Configuration:

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

@Configuration
public class MultipleDataSourceConfig {

    @Bean(name = "primaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "secondaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "primaryJdbcTemplate")
    public JdbcTemplate primaryJdbcTemplate(@Qualifier("primaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    @Bean(name = "secondaryJdbcTemplate")
    public JdbcTemplate secondaryJdbcTemplate(@Qualifier("secondaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

Explanation:

  • @Qualifier: Used to specify which bean to inject when multiple beans of the same type exist.
  • JdbcTemplate: A Spring class that simplifies JDBC operations.

application.properties Example:

# Primary DataSource settings
spring.datasource.primary.url=jdbc:mysql://localhost:3306/primarydb
spring.datasource.primary.username=root
spring.datasource.primary.password=secret
spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver

# Secondary DataSource settings
spring.datasource.secondary.url=jdbc:mysql://localhost:3306/secondarydb
spring.datasource.secondary.username=root
spring.datasource.secondary.password=secret
spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver

  1. Practical Exercises

Exercise 1: Configure a Single Data Source

  1. Create a new Spring Boot project.
  2. Add the necessary dependencies for MySQL.
  3. Configure a single data source in application.properties.
  4. Verify the configuration by creating a simple repository and performing a CRUD operation.

Solution:

  1. Create a new Spring Boot project using Spring Initializr.
  2. Add the following dependencies in pom.xml: 
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
  3. Configure the data source in application.properties: 
    spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
  4. Create a simple JPA entity and repository: 
    @Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // getters and setters
}

public interface UserRepository extends JpaRepository<User, Long> {
}
  5. Perform a CRUD operation in a service or controller to verify the configuration.

Exercise 2: Configure Multiple Data Sources

  1. Extend the previous exercise to configure a secondary data source.
  2. Create a new repository that uses the secondary data source.
  3. Perform a CRUD operation using both data sources.

Solution:

  1. Follow the steps in the "Using Multiple Data Sources" section to configure multiple data sources.
  2. Create a new repository for the secondary data source: 
    @Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // getters and setters
}

public interface ProductRepository extends JpaRepository<Product, Long> {
}
  3. Perform CRUD operations using both UserRepository and ProductRepository.

Conclusion

In this section, we covered how to configure data sources in a Spring Boot application using both application.properties and Java configuration. We also explored how to configure multiple data sources and provided practical exercises to reinforce the concepts. Understanding how to configure data sources is essential for building robust and scalable Spring Boot applications. In the next section, we will delve into creating JPA entities and using Spring Data repositories.

◄ Previous
◄
Next ►
►

Spring Boot Course

Module 1: Introduction to Spring Boot

Module 2: Spring Boot Basics

Module 3: Building RESTful Web Services

Module 4: Data Access with Spring Boot

Module 5: Spring Boot Security

Module 6: Testing in Spring Boot

Module 7: Advanced Spring Boot Features

Module 8: Deploying Spring Boot Applications

Module 9: Performance and Monitoring

Module 10: Best Practices and Tips

The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved