Leveraging Spring Boot for Multi-Source Data Access in MariaDB

April 06, 2022

In the realm of modern enterprise applications, data often resides in multiple sources. One of the challenges developers face is efficiently managing and accessing data from various databases. In this blog, we'll explore how to tackle this challenge using Spring Boot, one of the most popular frameworks for building Java-based applications, and MariaDB, a powerful open-source relational database management system.

Understanding the Need for Multi-Source Data Access

Consider a scenario where you have an e-commerce platform that needs to handle data from multiple sources:

Order Database: Stores information about customer orders.
Product Database: Contains details about the products in your catalog.
User Database: Manages user accounts and authentication.

In such cases, it's essential to access data from these different sources and potentially combine it for various operations. Spring Boot offers a convenient way to achieve this with its robust support for multiple data sources.

Setting Up Your Spring Boot Project

Before diving into multi-source data access, you'll need to set up a Spring Boot project. You can use Spring Initializr (https://start.spring.io/) or your favorite development environment to create a new project. Make sure to include the necessary dependencies, including Spring Web, Spring Data JPA, and MariaDB Driver, in your project configuration.

Configuring Multiple Data Sources

Spring Boot makes it relatively straightforward to configure multiple data sources. You need to define two separate DataSource beans, each pointing to a different MariaDB database. Create a configuration class for each data source.

Here's an example of how you can configure two data sources in your Spring Boot application:

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        basePackages = "com.example.repository.orders",
        entityManagerFactoryRef = "ordersEntityManagerFactory",
        transactionManagerRef = "ordersTransactionManager"
)
public class OrdersDataSourceConfig {

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

    @Primary
    @Bean(name = "ordersEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean
    entityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("ordersDataSource") DataSource dataSource
    ) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.model.orders")
                .persistenceUnit("orders")
                .build();
    }

    @Primary
    @Bean(name = "ordersTransactionManager")
    public PlatformTransactionManager transactionManager(
            @Qualifier("ordersEntityManagerFactory") EntityManagerFactory
                    entityManagerFactory
    ) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

In this configuration, we're creating a primary data source for the "orders" database. You can follow a similar pattern to configure a secondary data source for the "products" database.

Defining Entity Classes and Repositories

For each data source, define entity classes that represent the tables in the database. Create separate repositories for each data source to perform data access operations. Here's an example of an entity class for the "orders" database:

@Entity
@Table(name = "orders")
public class Order {
    // Entity fields, getters, and setters
}

And a repository interface for the "orders" database:

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    // Custom query methods if needed
}

Repeat this process for other data sources, such as "products" and "users."

Accessing Data from Multiple Sources

Now that you have configured data sources and defined repositories for each source, you can access data from multiple sources within your service classes or controllers. Here's an example of a service class that interacts with both "orders" and "products" databases:

@Service
public class OrderProductService {
    private final OrderRepository orderRepository;
    private final ProductRepository productRepository;

    @Autowired
    public OrderProductService(
            OrderRepository orderRepository,
            ProductRepository productRepository
    ) {
        this.orderRepository = orderRepository;
        this.productRepository = productRepository;
    }

    public List<Order> getAllOrders() {
        return orderRepository.findAll();
    }

    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    // Additional methods for combining data from different sources
}

In this example, the OrderProductService class injects both OrderRepository and ProductRepository. You can use these repositories to access data from the respective databases and perform operations like fetching orders and products.

Conclusion

Spring Boot's flexibility and support for multiple data sources make it a robust choice for applications that need to access data from various databases, such as MariaDB. With proper configuration and organization of repositories and services, you can seamlessly integrate data from different sources, allowing your application to work efficiently and provide valuable insights from diverse data sets. Whether you're building an e-commerce platform, a financial application, or any other system that deals with multi-source data, Spring Boot simplifies the task and helps you maintain a clean, modular codebase.

Blogs