TOC

Configurando um pool de conexão do Tomcat no Spring Boot

Configurando um pool de conexão do Tomcat no Spring Boot

1. Visão geral

Spring Boot é uma camada opinativa - mas poderosa - de abstração colocada em cima de uma plataforma Spring simples, o que torna o desenvolvimento de aplicativos autônomos e da web um acéfalo. O Spring Boot fornece algumas dependências úteis "iniciais", destinadas a executar e testar aplicativos Java com um espaço mínimo.

One key component of these starter dependencies is spring-boot-starter-data-jpa. Isso nos permite usarJPAe trabalhar com bancos de dados de produção usando algumas implementações de pool de conexão JDBC populares, comoHikariCPeTomcat JDBC Connection Pool.

Neste tutorial,we’ll learn how to configure a Tomcat connection pool in Spring Boot.

2. As dependências do Maven

O Spring Boot usa o HikariCP como o pool de conexão padrão, devido ao seu desempenho notável e recursos prontos para empresas.

Veja como Spring Boot configura automaticamente uma fonte de dados de pool de conexão:

  1. O Spring Boot procurará o HikariCP no caminho de classe e o usará por padrão quando presente

  2. Se o HikariCP não for encontrado no caminho de classe, o Spring Boot irá pegar o Tomcat JDBC Connection Pool, se estiver disponível

  3. Se nenhuma dessas opções estiver disponível, o Spring Boot escolheráApache Commons DBCP2, se estiver disponível

Para configurar um pool de conexão JDBC Tomcat em vez do HikariCP padrão, vamosexclude HikariCP from the spring-boot-starter-data-jpa dependency and add the tomcat-jdbc Maven dependency para nossopom.xml: 


    org.springframework.boot
    spring-boot-starter-data-jpa
    
        
            com.zaxxer
            HikariCP
        
    


    org.apache.tomcat
    tomcat-jdbc
    9.0.10


    com.h2database
    h2
    1.4.197
    runtime

Esta abordagem simples nos permite obter o Spring Boot usando um pool de conexão Tomcat sem ter que escrever uma classe@Configuratione definir programaticamente um beanDataSource.

It’s also worth noting that in this case, we’re using the H2 in-memory database. Spring Boot will autoconfigure H2 for us, without having to specify a database URL, user, and password.

Precisamos apenas incluir a dependência correspondente no arquivo“pom.xml” e o Spring Boot fará o resto para nós.

Alternativamente,it’s possible to skip the connection pool scanning algorithm that Spring Boot uses and explicitly specify a connection pooling datasource em“application.properties” file, usando a propriedade“spring.datasource.type”: 

spring.datasource.type=org.apache.tomcat.jdbc.pool.DataSource
// other spring datasource properties

3. Ajustando o pool de conexão com o arquivo “application.properties”

Depois de configurarmos com sucesso um pool de conexão Tomcat no Spring Boot,it’s very likely that we’ll want to set up some additional properties, for optimizing its performance and suiting some specific requirements.

Podemos fazer isso no arquivo“application.properties”: 

spring.datasource.tomcat.initial-size=15
spring.datasource.tomcat.max-wait=20000
spring.datasource.tomcat.max-active=50
spring.datasource.tomcat.max-idle=15
spring.datasource.tomcat.min-idle=8
spring.datasource.tomcat.default-auto-commit=true

Observe que configuramos algumas propriedades adicionais de pool de conexão, como o tamanho inicial do pool e o número máximo e mínimo de conexões inativas.

Também podemos especificar algumas propriedades específicas do Hibernate: 

# Hibernate specific properties
spring.jpa.show-sql=false
spring.jpa.hibernate.ddl-auto=update
spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.ImprovedNamingStrategy
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.properties.hibernate.id.new_generator_mappings=false

4. Testando o pool de conexão

Vamos escrever um teste de integração simples para verificar se o Spring Boot configurou corretamente o pool de conexão: 

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBootTomcatConnectionPoolIntegrationTest {

    @Autowired
    private DataSource dataSource;

    @Test
    public void givenTomcatConnectionPoolInstance_whenCheckedPoolClassName_thenCorrect() {
        assertThat(dataSource.getClass().getName())
          .isEqualTo("org.apache.tomcat.jdbc.pool.DataSource");
    }
}

5. Um exemplo de aplicativo de linha de comando

Com todo o encanamento do pool de conexão já configurado, vamos construir um aplicativo de linha de comando simples.

Fazendo isso, podemos ver como realizar algumas operações CRUD em um banco de dados H2 usando a poderosa camadaDAO queSpring Data JPA (e transitivamente, Spring Boot) fornece fora da caixa.

Para obter um guia detalhado sobre como começar a usar Spring Data JPA, verifiquethis article.

5.1. A classe de entidadeCustomer

Vamos primeiro definir uma classe de entidade ingênuaCustomer: 

@Entity
@Table(name = "customers")
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;
    @Column(name = "first_name")
    private String firstName;

    // standard constructors / getters / setters / toString
}

5.2. A interfaceCustomerRepository

Nesse caso, queremos apenas realizar operações CRUD em algumas entidadesCustomer. Além disso, precisamos buscar todos os clientes que correspondem a um determinado sobrenome.

Então,all that we have to do is to extend Spring Data JPA’s CrudRepository interface and define a tailored method: 

public interface CustomerRepository extends CrudRepository {
    List findByLastName(String lastName);
}

Agora podemos facilmente buscar uma entidadeCustomer por seu sobrenome.

5.3. A implementação deCommandLineRunner

Finalmente, precisamos pelo menos persistir algumas entidadesCustomer no banco de dados everify that our Tomcat connection pool is actually working.

Vamos criar uma implementação da interfaceCommandLineRunner do Spring Boot. O Spring Boot inicializará a implementação antes de iniciar o aplicativo: 

public class CommandLineCrudRunner implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(CommandLineCrudRunner.class);

    @Autowired
    private final CustomerRepository repository;

    public void run(String... args) throws Exception {
        repository.save(new Customer("John", "Doe"));
        repository.save(new Customer("Jennifer", "Wilson"));

        logger.info("Customers found with findAll():");
        repository.findAll().forEach(c -> logger.info(c.toString()));

        logger.info("Customer found with findById(1L):");
        Customer customer = repository.findById(1L)
          .orElseGet(() -> new Customer("Non-existing customer", ""));
        logger.info(customer.toString());

        logger.info("Customer found with findByLastName('Wilson'):");
        repository.findByLastName("Wilson").forEach(c -> {
            logger.info(c.toString());
        });
    }
}

Resumindo, a classeCommandLineCrudRunner primeiro salva algumas entidadesCustomer no banco de dados. Em seguida, ele busca o primeiro usando o métodofindById(). Por fim, ele recupera um cliente com o métodofindByLastName().

5.4. Executando o aplicativo Spring Boot

Obviamente, a última coisa que precisamos fazer é apenas executar o aplicativo de amostra. Em seguida, podemos ver o conjunto de conexões Spring Boot / Tomcat em ação: 

@SpringBootApplication
public class SpringBootConsoleApplication {

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

6. Conclusão

Neste tutorial, aprendemos como configurar e usar um pool de conexão do Tomcat no Spring Boot. Além disso, desenvolvemos um aplicativo básico de linha de comando para mostrar como é fácil trabalhar com o Spring Boot, um pool de conexões Tomcat e o banco de dados H2.

Como de costume, todos os exemplos de código mostrados neste tutorial estão disponíveisover on GitHub.

Related