DEV Community: Felipe Moysés

Como ter múltiplos datasources em seu projeto spring boot

Felipe Moysés — Sun, 24 Sep 2023 01:00:39 +0000

Volta e meia, nos encontramos em corner cases no nosso dia-a-dia
Recentemente tive que, de forma não usual, acessar duas bases no mesmo projeto java com spring data.

Para resolver essa necessidade, tive que realizar algumas alterações na configuração.

Irei mostrar nessa receita rápida uma forma de atingir esse resultado.

Mise en Place

Foto de Rudy Issa na Unsplash

Para acompanhar esse post você pode seguir a seguinte receita, alguns itens podem ser substituídos por outros análogos ;)

Java 17
Spring Boot 3.1.3. Obrigatório.
Mysql
Editor de texto da tua escolha.
Docker

O projeto final está disponível no github.

Montando o projeto

Em Spring Initializr, adicionamos as seguintes dependências:

Spring Data JPA
MySQL Driver
Lombok

Abrindo nosso projeto em algum editor de código/IDE, iremos criar a mesma estrutura de pacote que está no github, nada de Clean Architecture, pois não é objeto desse post.

O que nos interessa são os pacote config e o arquivo application.properties.

Os pacotes:

Arquivo de configuração do projeto

Para cada base de dados teremos uma url, um usuário e uma senha.
Por questão de simplicidade, não utilizaremos variáveis de ambiente para esconder informações sensíveis.

#### FISH
spring.first-datasource.url=jdbc:mysql://127.0.0.1:3309/rare_fishes_db?useSSL=false&allowPublicKeyRetrieval=true
spring.first-datasource.username=user
spring.first-datasource.password=pass

#### SHIPPING
spring.second-datasource.url=jdbc:mysql://127.0.0.1:3307/shipping_db?useSSL=false&allowPublicKeyRetrieval=true
spring.second-datasource.username=user
spring.second-datasource.password=pass

Datasources

O prato principal é a configuração de nossa aplicação.
Como dito anteriormente, cada base terá a tua respectiva classe de configuração de dados

Vamos nos debruçar sobre a primeira classe: PrimaryDataSourceConfiguration

Iremos perceber um padrão onde as anotações, beans e outras estruturas, estão sendo feitas manualmente.
Normalmente, é algo transparente, o framework assegura o devido funcionamento. Como estamos tratando de um caso que foge da regra, precisamos realizar esse trabalho.

PrimaryDataSourceConfiguration é uma classe de configuração com algumas coisas especiais, primeira delas é a anotação @EnableTransactionManagement.
Essa anotação indica ao Spring o datasource para realizar o gerenciamento de transações.
Bem, como assim?
Transações na base de dados são unidades de trabalho que contém instruções/operações realizadas no banco.
O Spring realiza isso para você de forma transparente, seja o commit ou o rollback de uma operação, por exemplo.
Claro, existem outros tipos de transações, sugiro essa leitura.

@EnableJpaRepositories, tem a responsabilidade de identificar e habilitar os repositórios JPA.
Ela possui diversos elementos opcionais.
No caso, temos 3 e eles estão relacionados com beans que criaremos a seguir.

entityManagerFactoryRef e o Bean LocalContainerEntityManagerFactoryBean

Criaremos um bean LocalContainerEntityManagerFactoryBean e faremos referência dele em entityManagerFactoryRef.
O Bean em questão servirá para configuramos o nosso datasource, incluímos o vendor jpa(Hibernate, EclipseLink, etc), o próprio datasource, etc.

@Autowired
    private Environment env;

    @Bean
    @Primary
    public LocalContainerEntityManagerFactoryBean primaryEntityManager() {
        LocalContainerEntityManagerFactoryBean em = 
            new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(primaryDataSource());
        em.setPackagesToScan(
                "com.nssp.rarefish.model.fish");
        HibernateJpaVendorAdapter vendorAdapter 
            = new HibernateJpaVendorAdapter();
        em.setJpaVendorAdapter(vendorAdapter);
        HashMap<String, Object> properties = new HashMap<>();
        properties.put("hibernate.dialect",
                env.getProperty("spring.jpa.properties.hibernate.dialect"));
        properties.put("spring.jpa.generate-ddl",
                env.getProperty("spring.jpa.generate-ddl"));
        properties.put("hibernate.hbm2ddl.auto",
                env.getProperty("spring.jpa.hibernate.ddl-auto"));
                em.setJpaPropertyMap(properties);
                return em;

    }

transactionManagerRef e o Bean primaryTransactionManager

Utilizando nosso bean criado no passo anterior, estamos habilitando em nossa aplicação a infraestrutura necessária para realizar operações como criar, dar rollback, efetuar commit, das transações.

@Primary
    @Bean
    public PlatformTransactionManager primaryTransactionManager() {
        JpaTransactionManager transactionManager
            = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(
                primaryEntityManager().getObject());
        return transactionManager;
    }

Datasource

Instanciamos o nosso DriverManagerDataSource com as informações de URL, de nome de usuário e de senha.

@Primary
    @Bean
    public DataSource primaryDataSource() {
        DriverManagerDataSource dataSource 
            = new DriverManagerDataSource();
        dataSource.setDriverClassName(
                env.getProperty("spring.datasource.drive-class-name"));
        dataSource.setUrl(env.getProperty("spring.first-datasource.url"));
        dataSource.setUsername(env.getProperty("spring.first-datasource.username"));
        dataSource.setPassword(env.getProperty("spring.first-datasource.password"));
        return dataSource;
    }

Dica: podemos substituir dessa forma pela seguinte

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

Juntando tudo

package com.nssp.rarefish.config;

import java.util.HashMap;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
    entityManagerFactoryRef = "primaryEntityManager",
    transactionManagerRef = "primaryTransactionManager",
    basePackages = {"com.nssp.rarefish.model.fish"})
public class PrimaryDataSourceConfiguration {
    @Autowired
    private Environment env;

    @Bean
    @Primary
    public LocalContainerEntityManagerFactoryBean primaryEntityManager() {
        LocalContainerEntityManagerFactoryBean em = 
            new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(primaryDataSource());
        em.setPackagesToScan(
                "com.nssp.rarefish.model.fish");
        HibernateJpaVendorAdapter vendorAdapter 
            = new HibernateJpaVendorAdapter();
        em.setJpaVendorAdapter(vendorAdapter);
        HashMap<String, Object> properties = new HashMap<>();
        properties.put("hibernate.dialect",
                env.getProperty("spring.jpa.properties.hibernate.dialect"));
        properties.put("spring.jpa.generate-ddl",
                env.getProperty("spring.jpa.generate-ddl"));
        properties.put("hibernate.hbm2ddl.auto",
                env.getProperty("spring.jpa.hibernate.ddl-auto"));
                em.setJpaPropertyMap(properties);
                return em;

    }

    @Primary
    @Bean
    public DataSource primaryDataSource() {
        DriverManagerDataSource dataSource 
            = new DriverManagerDataSource();
        dataSource.setDriverClassName(
                env.getProperty("spring.datasource.drive-class-name"));
        dataSource.setUrl(env.getProperty("spring.first-datasource.url"));
        dataSource.setUsername(env.getProperty("spring.first-datasource.username"));
        dataSource.setPassword(env.getProperty("spring.first-datasource.password"));
        return dataSource;
    }

    @Primary
    @Bean
    public PlatformTransactionManager primaryTransactionManager() {
        JpaTransactionManager transactionManager
            = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(
                primaryEntityManager().getObject());
        return transactionManager;
    }
}

E com isso, temos 2 datasources de bancos de dados distintos prontos a serem utilizados!

Obrigado!

Um olhar sobre PagingAndSortingRepository

Felipe Moysés — Sun, 22 Jan 2023 01:18:49 +0000

TL;DR

O método findAll da interface PagingAndSortingRepository, faz uma query/busca adicional à sua base de dados.

Serendipidade no App do Pássaro Azul

Esses dias durante um doom scrolling no twitter, me deparei com um post interessante sobre o PagingAndSortingRepository do Spring Data, basicamente era um alerta sobre a execução de uma query adicional(um simples count) no método findAll, e, como isso dependendo do teu cenário, poderia ser um gargalo.

Esteja atent@ que o método findAll do PagingAndSortingRepository do Spring Data realizará uma query adicional, se você possue uma consulta lenta, ela levará o dobro do tempo!

Vendo para crer

Isso me chamou atenção e fui buscar informações.
Olhei na documentação e não encontrei os detalhes específicos sobre isso.
Resolvi subir um projeto que já tenho preparado para vários tipos de experimentações e rodar esse cenário

Big surprise: realmente, executa a query adicional de count

Conforme o autor do twit responde uma possível contramedida é utilizar getBy(Pageable pageable) porém acaba abrindo mão dos metadados do objeto Page.

Mise en Place

Foto de Rudy Issa na Unsplash

Para verificar esse caso, utilizei no projeto:

Java 11+
Spring Boot 3+
Spring Data
Spring Web
Actuator
Lombok (opcional)
IntelliJ IDEA Community Edition 2022.3.1 (opcional)
Mysql Employee DB Sample

O repositório já implementado pode ser clonado e/ou verificado aqui!

Interface TitlesRepository

package com.nssp.employees.data.repositories;

import com.nssp.employees.data.models.Titles;
import org.springframework.data.domain.Pageable;
import org.springframework.data.repository.PagingAndSortingRepository;

import java.util.List;

public interface TitlesRepository extends PagingAndSortingRepository<Titles, Long> {
    List<Titles> findBy(Pageable pageable);
}

Classe principal e de controller

package com.nssp.employees;

import com.nssp.employees.data.models.Titles;
import com.nssp.employees.data.repositories.EmployeesRepository;
import com.nssp.employees.data.repositories.TitlesRepository;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.concurrent.TimeUnit;

@SpringBootApplication
@RestController
@RequestMapping("/")
public class EmployeesApplication {

    private EmployeesRepository repository;
    private TitlesRepository titlesRepository;

    public EmployeesApplication(final EmployeesRepository repository,
                                final TitlesRepository titlesRepository) {
        this.repository = repository;
        this.titlesRepository = titlesRepository;
    }

    public static void main(String[] args) {
        SpringApplication.run(EmployeesApplication.class, args);
    }

    @GetMapping("page")
    public Page<Titles> get() {
        long startTime = System.nanoTime();
        var response = this.titlesRepository.findAll(PageRequest.of(1, 10000));
        long endTime = System.nanoTime();
        long duration = TimeUnit.SECONDS.convert( (endTime - startTime), TimeUnit.NANOSECONDS);
        System.out.println("Page time: "+duration);
        return response;
    }

    @GetMapping("list")
    public List<Titles> getList() {
        long startTime = System.nanoTime();
        var response = this.titlesRepository.findBy(PageRequest.of(1, 10000));
        long endTime = System.nanoTime();
        long duration = TimeUnit.SECONDS.convert( (endTime - startTime), TimeUnit.NANOSECONDS);
        System.out.println("List time: "+duration);
        return response;
    }
}

Console da execução(list):

Hibernate: select t1_0.emp_no,t1_0.title,t1_0.to_date,t1_0.from_date from titles t1_0 limit ?,?
List time: 209

Console da execução(findAll):

Hibernate: select t1_0.emp_no,t1_0.title,t1_0.to_date,t1_0.from_date from titles t1_0 limit ?,?
Hibernate: select count(*) from titles t1_0
Page time: 264

Com o actuator liberado temos as seguintes métricas:

http://localhost:8080/actuator/metrics/http.server.requests?tag=uri:/page

{
  "name": "http.server.requests",
  "baseUnit": "seconds",
  "measurements": [
    {
      "statistic": "COUNT",
      "value": 4
    },
    {
      "statistic": "TOTAL_TIME",
      "value": 2.840016801
    },
    {
      "statistic": "MAX",
      "value": 1.752134
    }
  ],
  "availableTags": [
    {
      "tag": "exception",
      "values": [
        "none"
      ]
    },
    {
      "tag": "method",
      "values": [
        "GET"
      ]
    },
    {
      "tag": "error",
      "values": [
        "none"
      ]
    },
    {
      "tag": "outcome",
      "values": [
        "SUCCESS"
      ]
    },
    {
      "tag": "status",
      "values": [
        "200"
      ]
    }
  ]
}

http://localhost:8080/actuator/metrics/http.server.requests?tag=uri:/list

{
  "name": "http.server.requests",
  "baseUnit": "seconds",
  "measurements": [
    {
      "statistic": "COUNT",
      "value": 3
    },
    {
      "statistic": "TOTAL_TIME",
      "value": 1.4389705
    },
    {
      "statistic": "MAX",
      "value": 0
    }
  ],
  "availableTags": [
    {
      "tag": "exception",
      "values": [
        "none"
      ]
    },
    {
      "tag": "method",
      "values": [
        "GET"
      ]
    },
    {
      "tag": "error",
      "values": [
        "none"
      ]
    },
    {
      "tag": "outcome",
      "values": [
        "SUCCESS"
      ]
    },
    {
      "tag": "status",
      "values": [
        "200"
      ]
    }
  ]
}

Temos numa pesquisa simples de 10k de registros uma diferença sensível na casa dos milisegundos

Discussão

Qual o melhor? qual o pior?
Depende do teu contexto, do tradeoff que você pode fazer
Pois o que você perde ao não utilizar a paginação são dados como número total de elementos, ordenação, etc.

Metadados

"pageable": {
    "sort": {
      "empty": true,
      "sorted": false,
      "unsorted": true
    },
    "offset": 100,
    "pageNumber": 1,
    "pageSize": 100,
    "paged": true,
    "unpaged": false
  },
  "totalPages": 4434,
  "totalElements": 443308,
  "last": false,
  "size": 100,
  "number": 1,
  "sort": {
    "empty": true,
    "sorted": false,
    "unsorted": true
  },
  "numberOfElements": 100,
  "first": false,
  "empty": false

Espero que tenha sido interessante essa análise
E você, vai pesar se vale ou não a pena na tua próxima codificação?

Obrigado.