Spring Boot JPA - configurando a reconexão automática

Eu tenho um pequeno aplicativo da web Spring Boot JPA. Ele é implantado no Amazon Beanstalk e usa um Amazon RDS para dados persistentes. No entanto, não é usado com frequência e, portanto, falha depois de um tempo com este tipo de exceção:

com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: O último pacote recebido com sucesso do servidor foi 79.870.633 milissegundos atrás.
O último pacote enviado com sucesso ao servidor foi 79.870.634 milissegundos atrás. é mais longo do que o valor configurado pelo servidor de 'wait_timeout'. Você deve considerar expirar e / ou testar a validade da conexão antes de usar em seu aplicativo, aumentando os valores configurados do servidor para tempos limite do cliente ou usando a propriedade de conexão Conector / J 'autoReconnect = true' para evitar esse problema.

Não tenho certeza de como definir essa configuração e não consigo encontrar informações sobre ela em http://spring.io (um site muito bom, no entanto). Quais são algumas idéias ou indicações para informações?

Presumo que o boot esteja configurando o DataSourcepara você. Neste caso, e já que você está usando MySQL, você pode adicionar o seguinte ao seu application.propertiesaté 1,3

spring.datasource.testOnBorrow=true
spring.datasource.validationQuery=SELECT 1

Como djxak observado no comentário, 1.4+ define espaços de nomes específicos para as quatro ligações piscinas da mola de arranque suporta: tomcat, hikari, dbcp, dbcp2( dbcpé suspenso a partir de 1.5). Você precisa verificar qual pool de conexão está usando e se esse recurso é compatível. O exemplo acima era para tomcat, então você teria que escrevê-lo da seguinte maneira em 1.4+:

spring.datasource.tomcat.testOnBorrow=true 
spring.datasource.tomcat.validationQuery=SELECT 1

Observe que o uso de nãoautoReconnect é recomendado :

O uso deste recurso não é recomendado, porque tem efeitos colaterais relacionados ao estado da sessão e consistência de dados quando os aplicativos não manipulam SQLExceptions corretamente, e só foi projetado para ser usado quando você não consegue configurar seu aplicativo para lidar com SQLExceptions resultantes de conexões mortas e obsoletas corretamente.

As sugestões acima não funcionaram para mim. O que realmente funcionou foi a inclusão das seguintes linhas no application.properties

spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 3600000
spring.datasource.validationQuery = SELECT 1

Você pode encontrar a explicação aqui

A configuração spring.datasource.tomcat.testOnBorrow=trueem application.properties não funcionou.

A configuração programática como abaixo funcionou sem problemas.

import org.apache.tomcat.jdbc.pool.DataSource;
import org.apache.tomcat.jdbc.pool.PoolProperties;    

@Bean
public DataSource dataSource() {
    PoolProperties poolProperties = new PoolProperties();
    poolProperties.setUrl(this.properties.getDatabase().getUrl());         
    poolProperties.setUsername(this.properties.getDatabase().getUsername());            
    poolProperties.setPassword(this.properties.getDatabase().getPassword());

    //here it is
    poolProperties.setTestOnBorrow(true);
    poolProperties.setValidationQuery("SELECT 1");

    return new DataSource(poolProperties);
}

Acabei de mudar para o Spring Boot 1.4 e descobri que essas propriedades foram renomeadas:

spring.datasource.dbcp.test-while-idle=true
spring.datasource.dbcp.time-between-eviction-runs-millis=3600000
spring.datasource.dbcp.validation-query=SELECT 1

a resposta de whoami é a correta. Usando as propriedades conforme sugerido, não consegui fazer isso funcionar (usando Spring Boot 1.5.3.RELEASE)

Estou adicionando minha resposta, pois é uma classe de configuração completa, então pode ajudar alguém usando Spring Boot:

@Configuration
@Log4j
public class SwatDataBaseConfig {

    @Value("${swat.decrypt.location}")
    private String fileLocation;

    @Value("${swat.datasource.url}")
    private String dbURL;

    @Value("${swat.datasource.driver-class-name}")
    private String driverName;

    @Value("${swat.datasource.username}")
    private String userName;

    @Value("${swat.datasource.password}")
    private String hashedPassword;

    @Bean
    public DataSource primaryDataSource() {
        PoolProperties poolProperties = new PoolProperties();
        poolProperties.setUrl(dbURL);
        poolProperties.setUsername(userName);
        poolProperties.setPassword(password);
        poolProperties.setDriverClassName(driverName);
        poolProperties.setTestOnBorrow(true);
        poolProperties.setValidationQuery("SELECT 1");
        poolProperties.setValidationInterval(0);
        DataSource ds = new org.apache.tomcat.jdbc.pool.DataSource(poolProperties);
        return ds;
    }
}

Eu tenho um problema semelhante. Spring 4 e Tomcat 8. Eu resolvo o problema com a configuração do Spring

<bean id="dataSource" class="org.apache.tomcat.jdbc.pool.DataSource" destroy-method="close">
    <property name="initialSize" value="10" />
    <property name="maxActive" value="25" />
    <property name="maxIdle" value="20" />
    <property name="minIdle" value="10" />
     ...
    <property name="testOnBorrow" value="true" />
    <property name="validationQuery" value="SELECT 1" />
 </bean>

Eu testei. Isso funciona bem! Essas duas linhas fazem tudo para se reconectar ao banco de dados:

<property name="testOnBorrow" value="true" />
<property name="validationQuery" value="SELECT 1" />

Caso alguém esteja usando DataSource personalizado

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

As propriedades devem ser semelhantes às seguintes. Observe @ConfigurationProperties com prefixo. O prefixo é tudo antes do nome real da propriedade

management.datasource.test-on-borrow=true
management.datasource.validation-query=SELECT 1

Uma referência para Spring Versão 1.4.4.RELEASE

Como algumas pessoas já apontaram, spring-boot 1.4+, tem namespaces específicos para os quatro pools de conexões. Por padrão, hikaricp é usado no spring-boot 2+. Portanto, você terá que especificar o SQL aqui. O padrão é SELECT 1. Aqui está o que você precisa para o DB2, por exemplo: spring.datasource.hikari.connection-test-query=SELECT current date FROM sysibm.sysdummy1

Advertência : se o seu driver suportar JDBC4, recomendamos enfaticamente não definir esta propriedade. Isso é para drivers "legados" que não suportam a API JDBC4 Connection.isValid (). Esta é a consulta que será executada pouco antes de uma conexão do pool ser fornecida a você para validar se a conexão com o banco de dados ainda está ativa. Novamente, tente executar o pool sem essa propriedade, o HikariCP registrará um erro se o seu driver não for compatível com JDBC4 para informá-lo. Padrão: nenhum

Para aqueles que desejam fazer isso em YAML com várias fontes de dados, há uma ótima postagem no blog sobre isso: https://springframework.guru/how-to-configure-multiple-data-sources-in-a-spring-boot -inscrição/

Basicamente, ele diz que vocês dois precisam configurar as propriedades da fonte de dados e a fonte de dados assim:

@Bean
@Primary
@ConfigurationProperties("app.datasource.member")
public DataSourceProperties memberDataSourceProperties() {
    return new DataSourceProperties();
}

@Bean
@Primary
@ConfigurationProperties("app.datasource.member.hikari")
public DataSource memberDataSource() {
    return memberDataSourceProperties().initializeDataSourceBuilder()
            .type(HikariDataSource.class).build();
}

Não se esqueça de remover @Primaryde outras fontes de dados.